bump version number

This reverts commit 9da5a836ce.

.coveragerc

@@ -0,0 +1,17 @@
+[report]
+exclude_lines =
+    # Skip @abstractmethod
+    @abstractmethod
+    @abc.abstractmethod
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:

.github/workflows/python-publish.yml

@@ -19,4 +19,4 @@ jobs:
       - name: Build using poetry and publish to PyPi
         uses: JRubics/poetry-publish@v1.11
         with:
-          pypi_token: ${{ secrets.PYPI_API_KEY }}
+          pypi_token: ${{ secrets.PYPI_API_KEY }}

.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: check-yaml
+    -   id: check-added-large-files
+-   repo: https://github.com/psf/black
+    rev: 22.6.0
+    hooks:
+    -   id: black
+-   repo: local
+    hooks:
+    -   id: unittest
+        name: unittest
+        entry: python -m unittest discover
+        language: system
+        'types': [python]
+        args: ["-p '*test.py'"] # Probably this option is absolutely not needed.
+        pass_filenames: false
+        stages: [commit]

README.md

@@ -5,6 +5,11 @@
 [![pypi](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
 [![python](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
 [![Read the Docs](https://img.shields.io/readthedocs/pyasic)](https://pyasic.readthedocs.io/en/latest/)
+[![GitHub](https://img.shields.io/github/license/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/blob/master/LICENSE.txt)
+[![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)](https://www.codefactor.io/repository/github/upstreamdata/pyasic)
+## Supported Miners
+Supported miners are listed in the docs, [here](https://pyasic.readthedocs.io/en/latest/miners/supported_types/)
+
 ## Documentation
 Documentation is located on Read the Docs as [pyasic](https://pyasic.readthedocs.io/en/latest/)
 
@@ -16,13 +21,15 @@ You can install pyasic directly from pip with the command `pip install pyasic`
 For those of you who aren't comfortable with code and developer tools, there are windows builds of GUI applications that use this library here -> (https://drive.google.com/drive/folders/1DjR8UOS_g0ehfiJcgmrV0FFoqFvE9akW?usp=sharing)
 
 ### Developers
-To use this repo, first download it, create a virtual environment, enter the virtual environment, and install relevant packages by navigating to this directory and running ```pip install -r requirements.txt``` on Windows or ```pip3 install -r requirements.txt``` on Mac or UNIX if the first command fails.
+To use this repo, first download it, create a virtual environment, enter the virtual environment, and install relevant packages by navigating to this directory and running ```pip install -r requirements-dev.txt``` on Windows or ```pip3 install -r requirements-dev.txt``` on Mac or UNIX if the first command fails.
 
-You can also use poetry by initializing and running ```poetry install```
+You can also use poetry by initializing and running ```poetry install```, and you will have to install `pre-commit` (`pip install pre-commit`).
+
+Finally, initialize pre-commit hooks with `pre-commit install`
 
 ### Interfacing with miners programmatically
 
-##### Note: If you are trying to interface with Whatsminers, there is a bug in the way they are interacted with on Windows, so to fix that you need to change the event loop policy using this code: 
+##### Note: If you are trying to interface with Whatsminers, there is a bug in the way they are interacted with on Windows, so to fix that you need to change the event loop policy using this code:
 ```python
 # need to import these 2 libraries, you need asyncio anyway so make sure you have sys imported
 import sys
@@ -64,18 +71,18 @@ async def scan_and_get_data():
     # Scan the network for miners
     # This function returns a list of miners of the correct type as a class
     miners: list = await net.scan_network_for_miners()
-    
+
     # We can now get data from any of these miners
     # To do them all we have to create a list of tasks and gather them
     tasks = [miner.get_data() for miner in miners]
     # Gather all tasks asynchronously and run them
     data = await asyncio.gather(*tasks)
-    
+
     # Data is now a list of MinerData, and we can reference any part of that
     # Print out all data for now
     for item in data:
         print(item)
-      
+
 if __name__ == "__main__":
     asyncio.run(scan_and_get_data())
 ```
@@ -87,7 +94,7 @@ if __name__ == "__main__":
 import asyncio
 import sys
 
-from pyasic.miners.miner_factory import MinerFactory
+from pyasic.miners import get_miner
 
 # Fix whatsminer bug
 # if the computer is windows, set the event loop policy to a WindowsSelector policy
@@ -99,8 +106,8 @@ if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.starts
 async def get_miner_data(miner_ip: str):
     # Use MinerFactory to get miner
     # MinerFactory is a singleton, so we can just get the instance in place
-    miner = await MinerFactory().get_miner(miner_ip)
-    
+    miner = await get_miner(miner_ip)
+
     # Get data from the miner
     data = await miner.get_data()
     print(data)
@@ -118,7 +125,7 @@ If needed, this library exposes a wrapper for the miner API that can be used for
 import asyncio
 import sys
 
-from pyasic.miners.miner_factory import MinerFactory
+from pyasic.miners import get_miner
 
 # Fix whatsminer bug
 # if the computer is windows, set the event loop policy to a WindowsSelector policy
@@ -128,12 +135,12 @@ if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.starts
 
 async def get_api_commands(miner_ip: str):
     # Get the miner
-    miner = await MinerFactory().get_miner(miner_ip)
-    
+    miner = await get_miner(miner_ip)
+
     # List all available commands
     print(miner.api.get_commands())
-    
-    
+
+
 if __name__ == "__main__":
     asyncio.run(get_api_commands("192.168.1.69"))
 ```
@@ -146,7 +153,7 @@ The miner API commands will raise an `APIError` if they fail with a bad status c
 import asyncio
 import sys
 
-from pyasic.miners.miner_factory import MinerFactory
+from pyasic.miners import get_miner
 
 # Fix whatsminer bug
 # if the computer is windows, set the event loop policy to a WindowsSelector policy
@@ -156,14 +163,14 @@ if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.starts
 
 async def get_api_commands(miner_ip: str):
     # Get the miner
-    miner = await MinerFactory().get_miner(miner_ip)
-    
+    miner = await get_miner(miner_ip)
+
     # Run the devdetails command
     # This is equivalent to await miner.api.send_command("devdetails")
     devdetails: dict = await miner.api.devdetails()
     print(devdetails)
-    
-    
+
+
 if __name__ == "__main__":
     asyncio.run(get_api_commands("192.168.1.69"))
 ```

docs/API/api.md

@@ -2,11 +2,12 @@
 ## Miner APIs
 Each miner has a unique API that is used to communicate with it.
 Each of these API types has commands that differ between them, and some commands have data that others do not.
-Each miner that is a subclass of `BaseMiner` should have an API linked to it as `Miner.api`.
+Each miner that is a subclass of [`BaseMiner`][pyasic.miners.BaseMiner] should have an API linked to it as `Miner.api`.
 
 All API implementations inherit from [`BaseMinerAPI`][pyasic.API.BaseMinerAPI], which implements the basic communications protocols.
 
-BaseMinerAPI should never be used unless inheriting to create a new miner API class for a new type of miner (which should be exceedingly rare).
+[`BaseMinerAPI`][pyasic.API.BaseMinerAPI] should never be used unless inheriting to create a new miner API class for a new type of miner (which should be exceedingly rare).
+[`BaseMinerAPI`][pyasic.API.BaseMinerAPI] cannot be instantiated directly, it will raise a `TypeError`.
 Use these instead -
 
 #### [BMMiner API][pyasic.API.bmminer.BMMinerAPI]

docs/data/error_codes.md

@@ -0,0 +1,33 @@
+# pyasic
+<br>
+
+## Whatsminer Error Codes
+::: pyasic.data.error_codes.WhatsminerError
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## Braiins OS Error Codes
+::: pyasic.data.error_codes.BraiinsOSError
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## X19 Error Codes
+::: pyasic.data.error_codes.X19Error
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## Innosilicon Error Codes
+::: pyasic.data.error_codes.InnosiliconError
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/index.md

@@ -5,6 +5,8 @@
 [![pypi](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
 [![python](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
 [![Read the Docs](https://img.shields.io/readthedocs/pyasic)](https://pyasic.readthedocs.io/en/latest/)
+[![GitHub](https://img.shields.io/github/license/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/blob/master/LICENSE.txt)
+[![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)](https://www.codefactor.io/repository/github/upstreamdata/pyasic)
 
 ## Intro
 Welcome to pyasic!  Pyasic uses an asynchronous method of communicating with asic miners on your network, which makes it super fast.
@@ -27,13 +29,13 @@ async def scan_miners():  # define async scan function to allow awaiting
     # create a miner network
     # you can pass in any IP and it will use that in a subnet with a /24 mask (255 IPs).
     network = MinerNetwork("192.168.1.50")  # this uses the 192.168.1.0-255 network
-    
+
     # scan for miners asynchronously
     # this will return the correct type of miners if they are supported with all functionality.
     miners = await network.scan_network_for_miners()
     print(miners)
 
-if __name__ == "__main__": 
+if __name__ == "__main__":
     asyncio.run(scan_miners())  # run the scan asynchronously with asyncio.run()
 ```
 
@@ -54,8 +56,8 @@ async def get_miners():  # define async scan function to allow awaiting
     miner_1 = await MinerFactory().get_miner("192.168.1.75")
     miner_2 = await MinerFactory().get_miner("192.168.1.76")
     print(miner_1, miner_2)
-    
-if __name__ == "__main__": 
+
+if __name__ == "__main__":
     asyncio.run(get_miners())  # get the miners asynchronously with asyncio.run()
 ```
 
@@ -76,7 +78,7 @@ async def gather_miner_data():
     print(miner_data)  # all data from the dataclass
     print(miner_data.hashrate)  # hashrate of the miner in TH/s
 
-if __name__ == "__main__": 
+if __name__ == "__main__":
     asyncio.run(gather_miner_data())
 ```
 
@@ -89,13 +91,143 @@ from pyasic.network import MinerNetwork  # miner network handles the scanning
 async def gather_miner_data():  # define async scan function to allow awaiting
     network = MinerNetwork("192.168.1.50")
     miners = await network.scan_network_for_miners()
-    
+
     # we need to asyncio.gather() all the miners get_data() functions to make them run together
     all_miner_data = await asyncio.gather(*[miner.get_data() for miner in miners])
 
     for miner_data in all_miner_data:
         print(miner_data)    # print out all the data one by one
 
-if __name__ == "__main__": 
+if __name__ == "__main__":
     asyncio.run(gather_miner_data())
 ```
+
+<br>
+
+## Controlling miners via pyasic
+Every miner class in pyasic must implement all the control functions defined in [`BaseMiner`][pyasic.miners.BaseMiner].
+
+These functions are
+[`check_light`](#check-light),
+[`fault_light_off`](#fault-light-off),
+[`fault_light_on`](#fault-light-on),
+[`get_config`](#get-config),
+[`get_data`](#get-data),
+[`get_errors`](#get-errors),
+[`get_hostname`](#get-hostname),
+[`get_model`](#get-model),
+[`reboot`](#reboot),
+[`restart_backend`](#restart-backend), and
+[`send_config`](#send-config).
+
+<br>
+
+### Check Light
+::: pyasic.miners.BaseMiner.check_light
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Fault Light Off
+::: pyasic.miners.BaseMiner.fault_light_off
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Fault Light On
+::: pyasic.miners.BaseMiner.fault_light_on
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Get Config
+::: pyasic.miners.BaseMiner.get_config
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Get Data
+::: pyasic.miners.BaseMiner.get_data
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Get Errors
+::: pyasic.miners.BaseMiner.get_errors
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Get Hostname
+::: pyasic.miners.BaseMiner.get_hostname
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Get Model
+::: pyasic.miners.BaseMiner.get_model
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Reboot
+::: pyasic.miners.BaseMiner.reboot
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Restart Backend
+::: pyasic.miners.BaseMiner.restart_backend
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+### Send Config
+::: pyasic.miners.BaseMiner.send_config
+    handler: python
+    options:
+        heading_level: 4
+
+<br>
+
+## [`MinerConfig`][pyasic.config.MinerConfig] and [`MinerData`][pyasic.data.MinerData]
+
+Pyasic implements a few dataclasses as helpers to make data return types consistent across different miners and miner APIs.
+
+<br>
+
+### [`MinerData`][pyasic.data.MinerData]
+
+[`MinerData`][pyasic.data.MinerData] is a return from the [`get_data()`](#get-data) function, and is used to have a consistent dataset across all returns.
+
+You can call [`MinerData.asdict()`][pyasic.data.MinerData.asdict] to get the dataclass as a dictionary, and there are many other helper functions contained in the class to convert to different data formats.
+
+<br>
+
+### [`MinerConfig`][pyasic.config.MinerConfig]
+
+[`MinerConfig`][pyasic.config.MinerConfig] is pyasic's way to represent a configuration file from a miner.
+It is the return from [`get_config()`](#get-config).
+
+Each miner has a unique way to convert the [`MinerConfig`][pyasic.config.MinerConfig] to their specific type, there are helper functions in the class.
+In most cases these helper functions should not be used, as [`send_config()`](#send-config) takes a [`MinerConfig`][pyasic.config.MinerConfig] and will do the conversion to the right type for you.

docs/miners/antminer/X17.md

@@ -57,3 +57,61 @@
     options:
         show_root_heading: false
         heading_level: 4
+
+
+## S17 (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17+ (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.S17_Plus.BOSMinerS17Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17 Pro (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.S17_Pro.BOSMinerS17Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17e (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.S17e.BOSMinerS17e
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17 (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17+ (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.T17_Plus.BOSMinerT17Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## T17e (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.T17e.BOSMinerT17e
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/antminer/X19.md

@@ -50,3 +50,45 @@
     options:
         show_root_heading: false
         heading_level: 4
+
+
+## S19 (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19_Pro.BOSMinerS19Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## S19j (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19j.BOSMinerS19j
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19j_Pro.BOSMinerS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T19 (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.T19.BOSMinerT19
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/antminer/X9.md

@@ -1,6 +1,16 @@
 # pyasic
 ## X9 Models
 
+
+## X9 (BOS)
+
+::: pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
 ## S9
 
 ::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9

docs/miners/base_miner.md

@@ -0,0 +1,10 @@
+# pyasic
+## Base Miner
+[`BaseMiner`][pyasic.miners.BaseMiner] is the basis for all miner classes, they all subclass (usually indirectly) from this class.
+
+You may not instantiate this class on its own, only subclass from it.  Trying to instantiate an instance of this class will raise `TypeError`.
+
+::: pyasic.miners.BaseMiner
+    handler: python
+    options:
+        heading_level: 4

docs/miners/innosilicon/T3X.md

@@ -0,0 +1,10 @@
+# pyasic
+## T3X Models
+
+## T3H+
+
+::: pyasic.miners.innosilicon.cgminer.T3X.T3H_Plus.CGMinerInnosiliconT3HPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/miner_factory.md

@@ -6,3 +6,15 @@
     options:
         show_root_heading: false
         heading_level: 4
+<br>
+
+## AnyMiner
+::: pyasic.miners.miner_factory.AnyMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+[`AnyMiner`][pyasic.miners.miner_factory.AnyMiner] is a placeholder type variable used for typing returns of functions.
+A function returning [`AnyMiner`][pyasic.miners.miner_factory.AnyMiner] will always return a subclass of [`BaseMiner`][pyasic.miners.BaseMiner],
+and is used to specify a function returning some arbitrary type of miner class instance.

docs/miners/supported_types.md

@@ -3,11 +3,26 @@
 
 Supported miner types are here on this list.  If your miner (or miner version) is not on this list, please feel free to [open an issue on GitHub](https://github.com/UpstreamData/pyasic/issues) to get it added.
 
-## Miner List
-
 ##### pyasic currently supports the following miners and subtypes:
 * Braiins OS+ Devices:
-    * All devices supported by BraiinsOS+ are supported here.
+    * X19 Series:
+        * [S19][pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19]
+        * [S19 Pro][pyasic.miners.antminer.bosminer.X19.S19_Pro.BOSMinerS19Pro]
+        * [S19j][pyasic.miners.antminer.bosminer.X19.S19j.BOSMinerS19j]
+        * [S19j Pro][pyasic.miners.antminer.bosminer.X19.S19j_Pro.BOSMinerS19jPro]
+        * [T19][pyasic.miners.antminer.bosminer.X19.T19.BOSMinerT19]
+    * X17 Series:
+        * [S17][pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17]
+        * [S17+][pyasic.miners.antminer.bosminer.X17.S17_Plus.BOSMinerS17Plus]
+        * [S17 Pro][pyasic.miners.antminer.bosminer.X17.S17_Pro.BOSMinerS17Pro]
+        * [S17e][pyasic.miners.antminer.bosminer.X17.S17e.BOSMinerS17e]
+        * [T17][pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17]
+        * [T17+][pyasic.miners.antminer.bosminer.X17.T17_Plus.BOSMinerT17Plus]
+        * [T17e][pyasic.miners.antminer.bosminer.X17.T17e.BOSMinerT17e]
+    * X9 Series:
+        * [S9][pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9]
+        * [S9i][pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9]
+        * [S9j][pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9]
 * Stock Firmware Whatsminers:
     * M3X Series:
         * [M30S][pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30S]:
@@ -22,11 +37,16 @@ Supported miner types are here on this list.  If your miner (or miner version) i
         * [M30S++][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlus]:
             * [VG30][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG30]
             * [VG40][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG40]
+            * [VH60][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVH60]
         * [M31S][pyasic.miners.whatsminer.btminer.M3X.M31S.BTMinerM31S]
         * [M31S+][pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlus]:
             * [VE20][pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlusVE20]
+        * [M32][pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32]
+            * [V20][pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32V20]
         * [M32S][pyasic.miners.whatsminer.btminer.M3X.M32S.BTMinerM32S]
     * M2X Series:
+        * [M20][pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20]:
+            * [V10][pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20V10]
         * [M20S][pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20S]:
             * [V10][pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV10]
             * [V20][pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV20]
@@ -71,3 +91,6 @@ Supported miner types are here on this list.  If your miner (or miner version) i
         * [A1026][pyasic.miners.avalonminer.cgminer.A10X.A1026.CGMinerAvalon1026]
         * [A1047][pyasic.miners.avalonminer.cgminer.A10X.A1047.CGMinerAvalon1047]
         * [A1066][pyasic.miners.avalonminer.cgminer.A10X.A1066.CGMinerAvalon1066]
+* Stock Firmware Innosilicon Miners:
+    * T3X Series:
+        * [T3H+][pyasic.miners.innosilicon.cgminer.T3X.T3H_Plus.CGMinerInnosiliconT3HPlus]

docs/miners/whatsminer/M2X.md

@@ -1,6 +1,22 @@
 # pyasic
 ## M2X Models
 
+## M20
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20V10
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20V10
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## M20S
 
 ::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20S

docs/miners/whatsminer/M3X.md

@@ -89,7 +89,7 @@
         show_root_heading: false
         heading_level: 4
 
-## M30S+VG40
+## M30S++VG40
 
 ::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG40
     handler: python
@@ -97,6 +97,14 @@
         show_root_heading: false
         heading_level: 4
 
+## M30S++VH60
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVH60
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 
 ## M31S
 
@@ -122,6 +130,22 @@
         show_root_heading: false
         heading_level: 4
 
+## M32
+
+::: pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M32V20
+
+::: pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32V20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## M32S
 
 ::: pyasic.miners.whatsminer.btminer.M3X.M32S.BTMinerM32S

docs/network/miner_network_range.md

@@ -1,7 +1,7 @@
 # pyasic
 ## Miner Network Range
 
-`MinerNetworkRange` is a class used by [`MinerNetwork`][pyasic.network.MinerNetwork] to handle any constructor stings.
+[`MinerNetworkRange`][pyasic.network.net_range.MinerNetworkRange] is a class used by [`MinerNetwork`][pyasic.network.MinerNetwork] to handle any constructor stings.
 The goal is to emulate what is produced by `ipaddress.ip_network` by allowing [`MinerNetwork`][pyasic.network.MinerNetwork] to get a list of hosts.
 This allows this class to be the [`MinerNetwork.network`][pyasic.network.MinerNetwork] and hence be used for scanning.
 

mkdocs.yml

@@ -11,7 +11,6 @@ nav:
           - BTMiner: "miners/backends/btminer.md"
           - CGMiner: "miners/backends/cgminer.md"
           - Hiveon: "miners/backends/hiveon.md"
-
       - Classes:
           - Antminer X9: "miners/antminer/X9.md"
           - Antminer X17: "miners/antminer/X17.md"
@@ -22,23 +21,26 @@ nav:
           - Avalon 10X: "miners/avalonminer/A10X.md"
           - Whatsminer M2X: "miners/whatsminer/M2X.md"
           - Whatsminer M3X: "miners/whatsminer/M3X.md"
-
+          - Innosilicon T3X: "miners/innosilicon/T3X.md"
   - Network:
       - Miner Network: "network/miner_network.md"
       - Miner Network Range: "network/miner_network_range.md"
-  - Data:
+  - Dataclasses:
       - Miner Data: "data/miner_data.md"
-  - Config:
+      - Error Codes: "data/error_codes.md"
       - Miner Config: "config/miner_config.md"
   - Advanced:
       - Miner APIs:
-          - Base: "API/api.md"
+          - Intro: "API/api.md"
           - BMMiner: "API/bmminer.md"
           - BOSMiner: "API/bosminer.md"
           - BTMiner: "API/btminer.md"
           - CGMiner: "API/cgminer.md"
           - Unknown: "API/unknown.md"
 
+      - Base Miner: "miners/base_miner.md"
+
+
 plugins:
   - mkdocstrings
   - search

poetry.lock

@@ -17,7 +17,7 @@ trio = ["trio (>=0.16)"]
 
 [[package]]
 name = "asyncssh"
-version = "2.11.0"
+version = "2.12.0"
 description = "AsyncSSH: Asynchronous SSHv2 client and server library"
 category = "main"
 optional = false
@@ -218,8 +218,8 @@ anyio = [
     {file = "anyio-3.6.1.tar.gz", hash = "sha256:413adf95f93886e442aea925f3ee43baa5a765a64a0f52c6081894f9992fdd0b"},
 ]
 asyncssh = [
-    {file = "asyncssh-2.11.0-py3-none-any.whl", hash = "sha256:7302348cbd54c58d3259da17f13e77912de1b005e366b15c8b183d948c8a91a8"},
-    {file = "asyncssh-2.11.0.tar.gz", hash = "sha256:59c36ce77ba9dda8dd57ad875776e7105ddb1fa851bc039bb3aeadeac4f67b56"},
+    {file = "asyncssh-2.12.0-py3-none-any.whl", hash = "sha256:6841c4242c606fd51188c974ec2f4887efeec67ecdfa5b84140711dacd985ab3"},
+    {file = "asyncssh-2.12.0.tar.gz", hash = "sha256:274101322c4b941823aeed8e1ab6e7be5191686c6db2d2bd35afeba30505e780"},
 ]
 certifi = [
     {file = "certifi-2022.6.15-py3-none-any.whl", hash = "sha256:fe86415d55e84719d75f8b69414f6438ac3547d2078ab91b67e779ef69378412"},

pyasic/API/__init__.py

@@ -19,33 +19,7 @@ import warnings
 import logging
 from typing import Union
 
-
-class APIError(Exception):
-    def __init__(self, *args):
-        if args:
-            self.message = args[0]
-        else:
-            self.message = None
-
-    def __str__(self):
-        if self.message:
-            return f"{self.message}"
-        else:
-            return "Incorrect API parameters."
-
-
-class APIWarning(Warning):
-    def __init__(self, *args):
-        if args:
-            self.message = args[0]
-        else:
-            self.message = None
-
-    def __str__(self):
-        if self.message:
-            return f"{self.message}"
-        else:
-            return "Incorrect API parameters."
+from pyasic.errors import APIError, APIWarning
 
 
 class BaseMinerAPI:
@@ -55,6 +29,11 @@ class BaseMinerAPI:
         # ip address of the miner
         self.ip = ipaddress.ip_address(ip)
 
+    def __new__(cls, *args, **kwargs):
+        if cls is BaseMinerAPI:
+            raise TypeError(f"Only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls)
+
     def get_commands(self) -> list:
         """Get a list of command accessible to a specific type of API on the miner.
 
@@ -111,7 +90,7 @@ If you are sure you want to use this command please use API.send_command("{comma
             data = await self.send_command(command, x19_command=ignore_x19_error)
         except APIError:
             logging.debug(f"{self.ip}: Handling X19 multicommand.")
-            data = await self._x19_multicommand(command.split("+"))
+            data = await self._x19_multicommand(*command.split("+"))
         logging.debug(f"{self.ip}: Received multicommand data.")
         return data
 

pyasic/API/btminer.py

@@ -19,11 +19,13 @@ import hashlib
 import binascii
 import base64
 import logging
+from typing import Union
 
 from passlib.handlers.md5_crypt import md5_crypt
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
-from pyasic.API import BaseMinerAPI, APIError
+from pyasic.errors import APIError
+from pyasic.API import BaseMinerAPI
 from pyasic.settings import PyasicSettings
 
 
@@ -182,13 +184,13 @@ class BTMinerAPI(BaseMinerAPI):
         pwd: str = PyasicSettings().global_whatsminer_password,
     ):
         super().__init__(ip, port)
-        self.admin_pwd = pwd
+        self.pwd = pwd
         self.current_token = None
 
     async def send_command(
         self,
-        command: str or bytes,
-        parameters: str or int or bool = None,
+        command: Union[str, bytes],
+        parameters: Union[str, int, bool] = None,
         ignore_errors: bool = False,
         **kwargs,
     ) -> dict:
@@ -259,7 +261,7 @@ class BTMinerAPI(BaseMinerAPI):
         data = await self.send_command("get_token")
 
         # encrypt the admin password with the salt
-        pwd = _crypt(self.admin_pwd, "$1$" + data["Msg"]["salt"] + "$")
+        pwd = _crypt(self.pwd, "$1$" + data["Msg"]["salt"] + "$")
         pwd = pwd.split("$")
 
         # take the 4th item from the pwd split
@@ -436,9 +438,10 @@ class BTMinerAPI(BaseMinerAPI):
 
     async def set_led(
         self,
+        auto: bool = True,
         color: str = "red",
-        period: int = 2000,
-        duration: int = 1000,
+        period: int = 60,
+        duration: int = 20,
         start: int = 0,
     ) -> dict:
         """Set the LED on the miner using the API.
@@ -449,6 +452,7 @@ class BTMinerAPI(BaseMinerAPI):
         changing the password of the miner using the Whatsminer tool.
 
         Parameters:
+            auto: Whether or not to reset the LED to auto mode.
             color: The LED color to set, either 'red' or 'green'.
             period: The flash cycle in ms.
             duration: LED on time in the cycle in ms.
@@ -458,16 +462,19 @@ class BTMinerAPI(BaseMinerAPI):
             A reply informing of the status of setting the LED.
         </details>
         """
-        command = {
-            "cmd": "set_led",
-            "color": color,
-            "period": period,
-            "duration": duration,
-            "start": start,
-        }
+        if not auto:
+            command = {
+                "cmd": "set_led",
+                "color": color,
+                "period": period,
+                "duration": duration,
+                "start": start,
+            }
+        else:
+            command = {"cmd": "set_led", "param": "auto"}
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
+        return await self.send_command(enc_command, ignore_errors=True)
 
     async def set_low_power(self) -> dict:
         """Set low power mode on the miner using the API.
@@ -541,6 +548,7 @@ class BTMinerAPI(BaseMinerAPI):
 
             A reply informing of the status of setting the password.
         """
+        self.pwd = old_pwd
         # check if password length is greater than 8 bytes
         if len(new_pwd.encode("utf-8")) > 8:
             raise APIError(
@@ -550,7 +558,12 @@ class BTMinerAPI(BaseMinerAPI):
         command = {"cmd": "update_pwd", "old": old_pwd, "new": new_pwd}
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
+        try:
+            data = await self.send_command(enc_command)
+        except APIError as e:
+            raise e
+        self.pwd = new_pwd
+        return data
 
     async def set_target_freq(self, percent: int) -> dict:
         """Update the target frequency.

pyasic/__init__.py

@@ -11,3 +11,51 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
+from pyasic.API.bmminer import BMMinerAPI
+from pyasic.API.bosminer import BOSMinerAPI
+from pyasic.API.btminer import BTMinerAPI
+from pyasic.API.cgminer import CGMinerAPI
+from pyasic.API.unknown import UnknownAPI
+
+from pyasic.config import MinerConfig
+
+from pyasic.data import (
+    MinerData,
+    BraiinsOSError,
+    InnosiliconError,
+    WhatsminerError,
+    X19Error,
+)
+
+from pyasic.errors import APIError, APIWarning
+
+from pyasic.miners import get_miner
+from pyasic.miners.base import AnyMiner
+from pyasic.miners.miner_factory import MinerFactory
+from pyasic.miners.miner_listener import MinerListener
+
+from pyasic.network import MinerNetwork
+
+from pyasic.settings import PyasicSettings
+
+__all__ = [
+    "BMMinerAPI",
+    "BOSMinerAPI",
+    "BTMinerAPI",
+    "CGMinerAPI",
+    "UnknownAPI",
+    "MinerConfig",
+    "MinerData",
+    "BraiinsOSError",
+    "InnosiliconError",
+    "WhatsminerError",
+    "X19Error",
+    "APIError",
+    "APIWarning",
+    "get_miner",
+    "AnyMiner",
+    "MinerFactory",
+    "MinerListener",
+    "MinerNetwork",
+    "PyasicSettings",
+]

pyasic/config/__init__.py

@@ -52,6 +52,19 @@ class _Pool:
                 self.password = data[key]
         return self
 
+    def as_wm(self, user_suffix: str = None) -> dict:
+        """Convert the data in this class to a dict usable by an Whatsminer device.
+
+        Parameters:
+             user_suffix: The suffix to append to username.
+        """
+        username = self.username
+        if user_suffix:
+            username = f"{username}{user_suffix}"
+
+        pool = {"url": self.url, "user": username, "pass": self.password}
+        return pool
+
     def as_x19(self, user_suffix: str = None) -> dict:
         """Convert the data in this class to a dict usable by an X19 device.
 
@@ -65,6 +78,23 @@ class _Pool:
         pool = {"url": self.url, "user": username, "pass": self.password}
         return pool
 
+    def as_inno(self, user_suffix: str = None) -> dict:
+        """Convert the data in this class to a dict usable by an Innosilicon device.
+
+        Parameters:
+             user_suffix: The suffix to append to username.
+        """
+        username = self.username
+        if user_suffix:
+            username = f"{username}{user_suffix}"
+
+        pool = {
+            f"Pool": self.url,
+            f"UserName": username,
+            f"Password": self.password,
+        }
+        return pool
+
     def as_avalon(self, user_suffix: str = None) -> str:
         """Convert the data in this class to a string usable by an Avalonminer device.
 
@@ -141,6 +171,32 @@ class _PoolGroup:
             pools.append(pool.as_x19(user_suffix=user_suffix))
         return pools
 
+    def as_inno(self, user_suffix: str = None) -> dict:
+        """Convert the data in this class to a list usable by an Innosilicon device.
+
+        Parameters:
+             user_suffix: The suffix to append to username.
+        """
+        pools = {}
+        for idx, pool in enumerate(self.pools[:3]):
+            pool_data = pool.as_inno(user_suffix=user_suffix)
+            for key in pool_data:
+                pools[f"{key}{idx+1}"] = pool_data[key]
+        return pools
+
+    def as_wm(self, user_suffix: str = None) -> List[dict]:
+        """Convert the data in this class to a list usable by an Whatsminer device.
+
+        Parameters:
+             user_suffix: The suffix to append to username.
+        """
+        pools = []
+        for pool in self.pools[:3]:
+            pools.append(pool.as_wm(user_suffix=user_suffix))
+        while len(pools) < 3:
+            pools.append({"url": None, "user": None, "pass": None})
+        return pools
+
     def as_avalon(self, user_suffix: str = None) -> str:
         """Convert the data in this class to a dict usable by an Avalonminer device.
 
@@ -191,7 +247,7 @@ class MinerConfig:
     temp_mode: Literal["auto", "manual", "disabled"] = "auto"
     temp_target: float = 70.0
     temp_hot: float = 80.0
-    temp_dangerous: float = 10.0
+    temp_dangerous: float = 100.0
 
     minimum_fans: int = None
     fan_speed: Literal[tuple(range(101))] = None  # noqa - Ignore weird Literal usage
@@ -287,6 +343,15 @@ class MinerConfig:
         self.pool_groups = pool_groups
         return self
 
+    def from_api(self, pools: list):
+        _pools = []
+        for pool in pools:
+            url = pool.get("URL")
+            user = pool.get("User")
+            _pools.append({"url": url, "user": user, "pass": "123"})
+        self.pool_groups = [_PoolGroup().from_dict({"pools": _pools})]
+        return self
+
     def from_dict(self, data: dict):
         """Convert an output dict of this class back into usable data and save it to this class.
 
@@ -318,6 +383,22 @@ class MinerConfig:
         """
         return self.from_dict(yaml.load(data, Loader=yaml.SafeLoader))
 
+    def as_wm(self, user_suffix: str = None) -> List[dict]:
+        """Convert the data in this class to a config usable by an Whatsminer device.
+
+        Parameters:
+            user_suffix: The suffix to append to username.
+        """
+        return self.pool_groups[0].as_wm(user_suffix=user_suffix)
+
+    def as_inno(self, user_suffix: str = None) -> dict:
+        """Convert the data in this class to a config usable by an Innosilicon device.
+
+        Parameters:
+            user_suffix: The suffix to append to username.
+        """
+        return self.pool_groups[0].as_inno(user_suffix=user_suffix)
+
     def as_x19(self, user_suffix: str = None) -> str:
         """Convert the data in this class to a config usable by an X19 device.
 

pyasic/data/__init__.py

@@ -12,8 +12,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import Union, List
 from dataclasses import dataclass, field, asdict
-from datetime import datetime
+from datetime import datetime, timezone
+import time
+import json
+
+from .error_codes import X19Error, WhatsminerError, BraiinsOSError, InnosiliconError
 
 
 @dataclass
@@ -48,14 +53,16 @@ class MinerData:
         right_chips: The number of chips online in the left board as an int.
         total_chips: The total number of chips on all boards.  Calculated automatically.
         ideal_chips: The ideal number of chips in the miner as an int.
-        perecent_ideal: The percent of total chips out of the ideal count.  Calculated automatically.
-        nominal: The nominal amount of chips in the miner.  Calculated automatically.
+        percent_ideal: The percent of total chips out of the ideal count.  Calculated automatically.
+        nominal: Whether the number of chips in the miner is nominal.  Calculated automatically.
         pool_split: The pool split as a str.
         pool_1_url: The first pool url on the miner as a str.
         pool_1_user: The first pool user on the miner as a str.
         pool_2_url: The second pool url on the miner as a str.
         pool_2_user: The second pool user on the miner as a str.
         errors: A list of errors on the miner.
+        fault_light: Whether or not the fault light is on as a boolean.
+        efficiency: Efficiency of the miner in J/TH (Watts per TH/s).  Calculated automatically.
     """
 
     ip: str
@@ -64,11 +71,11 @@ class MinerData:
     model: str = "Unknown"
     hostname: str = "Unknown"
     hashrate: float = 0
-    left_board_hashrate: float = 0
-    center_board_hashrate: float = 0
-    right_board_hashrate: float = 0
+    left_board_hashrate: float = 0.0
+    center_board_hashrate: float = 0.0
+    right_board_hashrate: float = 0.0
     temperature_avg: int = field(init=False)
-    env_temp: float = 0
+    env_temp: float = 0.0
     left_board_temp: int = 0
     left_board_chip_temp: int = 0
     center_board_temp: int = 0
@@ -93,10 +100,26 @@ class MinerData:
     pool_1_user: str = "Unknown"
     pool_2_url: str = ""
     pool_2_user: str = ""
-    errors: list = field(default_factory=list)
+    errors: List[
+        Union[WhatsminerError, BraiinsOSError, X19Error, InnosiliconError]
+    ] = field(default_factory=list)
+    fault_light: Union[bool, None] = None
+    efficiency: int = field(init=False)
 
     def __post_init__(self):
-        self.datetime = datetime.now()
+        self.datetime = datetime.now(timezone.utc).astimezone()
+
+    def __getitem__(self, item):
+        try:
+            return getattr(self, item)
+        except AttributeError:
+            raise KeyError(f"{item}")
+
+    def __setitem__(self, key, value):
+        return setattr(self, key, value)
+
+    def __iter__(self):
+        return iter([item for item in self.asdict()])
 
     @property
     def total_chips(self):  # noqa - Skip PyCharm inspection
@@ -142,5 +165,73 @@ class MinerData:
     def temperature_avg(self, val):
         pass
 
-    def asdict(self):
+    @property
+    def efficiency(self):  # noqa - Skip PyCharm inspection
+        if self.hashrate == 0:
+            return 0
+        return round(self.wattage / self.hashrate)
+
+    @efficiency.setter
+    def efficiency(self, val):
+        pass
+
+    def asdict(self) -> dict:
+        """Get this dataclass as a dictionary.
+
+        Returns:
+            A dictionary version of this class.
+        """
         return asdict(self)
+
+    def as_json(self) -> str:
+        """Get this dataclass as JSON.
+
+        Returns:
+            A JSON version of this class.
+        """
+        data = self.asdict()
+        data["datetime"] = str(int(time.mktime(data["datetime"].timetuple())))
+        return json.dumps(data)
+
+    def as_influxdb(self, measurement_name: str = "miner_data") -> str:
+        """Get this dataclass as [influxdb line protocol](https://docs.influxdata.com/influxdb/v2.4/reference/syntax/line-protocol/).
+
+        Parameters:
+            measurement_name: The name of the measurement to insert into in influxdb.
+
+        Returns:
+            A influxdb line protocol version of this class.
+        """
+        tag_data = [measurement_name]
+        field_data = []
+
+        tags = ["ip", "mac", "model", "hostname"]
+        for attribute in self:
+            if attribute in tags:
+                escaped_data = self[attribute].replace(" ", "\\ ")
+                tag_data.append(f"{attribute}={escaped_data}")
+                continue
+            if isinstance(self[attribute], str):
+                field_data.append(f'{attribute}="{self[attribute]}"')
+                continue
+            if isinstance(self[attribute], bool):
+                field_data.append(f"{attribute}={str(self[attribute]).lower()}")
+                continue
+            if isinstance(self[attribute], int):
+                field_data.append(f"{attribute}={self[attribute]}")
+                continue
+            if isinstance(self[attribute], float):
+                field_data.append(f"{attribute}={self[attribute]}")
+                continue
+            if attribute == "fault_light" and not self[attribute]:
+                field_data.append(f"{attribute}=false")
+                continue
+            if attribute == "errors":
+                for idx, item in enumerate(self[attribute]):
+                    field_data.append(f'error_{idx+1}="{item.error_message}"')
+
+        tags_str = ",".join(tag_data)
+        field_str = ",".join(field_data)
+        timestamp = str(int(time.mktime(self.datetime.timetuple()) * 1e9))
+
+        return " ".join([tags_str, field_str, timestamp])

pyasic/data/error_codes/X19.py

@@ -0,0 +1,29 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class X19Error:
+    """A Dataclass to handle error codes of X19 miners.
+
+    Attributes:
+        error_message: The error message as a string.
+    """
+
+    error_message: str
+
+    def asdict(self):
+        return asdict(self)

pyasic/data/error_codes/__init__.py

@@ -14,3 +14,5 @@
 
 from .whatsminer import WhatsminerError
 from .bos import BraiinsOSError
+from .X19 import X19Error
+from .innosilicon import InnosiliconError

pyasic/data/error_codes/bos.py

@@ -17,7 +17,11 @@ from dataclasses import dataclass, asdict
 
 @dataclass
 class BraiinsOSError:
-    """A Dataclass to handle error codes of BraiinsOS+ miners."""
+    """A Dataclass to handle error codes of BraiinsOS+ miners.
+
+    Attributes:
+        error_message: The error message as a string.
+    """
 
     error_message: str
 

pyasic/data/error_codes/innosilicon.py

@@ -0,0 +1,65 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from dataclasses import dataclass, field, asdict
+
+
+@dataclass
+class InnosiliconError:
+    """A Dataclass to handle error codes of Innosilicon miners.
+
+    Attributes:
+        error_code: The error code as an int.
+        error_message: The error message as a string.  Automatically found from the error code.
+    """
+
+    error_code: int
+    error_message: str = field(init=False)
+
+    @property
+    def error_message(self):  # noqa - Skip PyCharm inspection
+        if self.error_code in ERROR_CODES:
+            return ERROR_CODES[self.error_code]
+        return "Unknown error type."
+
+    @error_message.setter
+    def error_message(self, val):
+        pass
+
+    def asdict(self):
+        return asdict(self)
+
+
+ERROR_CODES = {
+    21: "The PLUG signal of the hash board is not detected.",
+    22: "Power I2C communication is abnormal.",
+    23: "The SPI of all hash boards is blocked.",
+    24: "Some of the hash boards fail to connect to the SPI'.",
+    25: "Hashboard failed to set frequency.",
+    26: "Hashboard failed to set voltage.",
+    27: "Chip BIST test failed.",
+    28: "Hashboard SPI communication is abnormal.",
+    29: "Power I2C communication is abnormal.",
+    30: "Pool connection failed.",
+    31: "Individual chips are damaged.",
+    32: "Over temperature protection.",
+    33: "Hashboard fault.",
+    34: "The data cables are not connected in the correct order.",
+    35: "No power output.",
+    36: "Hashboard fault.",
+    37: "Control board and/or hashboard do not match.",
+    40: "Power output is abnormal.",
+    41: "Power output is abnormal.",
+    42: "Hashboard fault.",
+}

pyasic/data/error_codes/whatsminer.py

@@ -17,7 +17,12 @@ from dataclasses import dataclass, field, asdict
 
 @dataclass
 class WhatsminerError:
-    """A Dataclass to handle error codes of Whatsminers."""
+    """A Dataclass to handle error codes of Whatsminers.
+
+    Attributes:
+        error_code: The error code as an int.
+        error_message: The error message as a string.  Automatically found from the error code.
+    """
 
     error_code: int
     error_message: str = field(init=False)
@@ -147,6 +152,7 @@ ERROR_CODES = {
     2020: "Pool 0 connection failed.",
     2021: "Pool 1 connection failed.",
     2022: "Pool 2 connection failed.",
+    2023: "Pool 3 connection failed.",
     2030: "High rejection rate on pool.",
     2040: "The pool does not support asicboost mode.",
     2310: "Hashrate is too low.",

pyasic/errors/__init__.py

@@ -0,0 +1,41 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+class APIError(Exception):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return f"{self.message}"
+        else:
+            return "Incorrect API parameters."
+
+
+class APIWarning(Warning):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return f"{self.message}"
+        else:
+            return "Incorrect API parameters."

pyasic/miners/__init__.py

@@ -12,105 +12,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import asyncssh
-import logging
 import ipaddress
+from typing import Union
 
-from pyasic.data import MinerData
+from pyasic.miners.base import BaseMiner, AnyMiner
+from pyasic.miners.miner_factory import MinerFactory
 
-
-class BaseMiner:
-    def __init__(self, *args) -> None:
-        self.ip = None
-        self.uname = "root"
-        self.pwd = "admin"
-        self.api = None
-        self.api_type = None
-        self.model = None
-        self.light = None
-        self.hostname = None
-        self.nominal_chips = 1
-        self.version = None
-        self.fan_count = 2
-        self.config = None
-
-    def __repr__(self):
-        return f"{'' if not self.api_type else self.api_type} {'' if not self.model else self.model}: {str(self.ip)}"
-
-    def __lt__(self, other):
-        return ipaddress.ip_address(self.ip) < ipaddress.ip_address(other.ip)
-
-    def __gt__(self, other):
-        return ipaddress.ip_address(self.ip) > ipaddress.ip_address(other.ip)
-
-    def __eq__(self, other):
-        return ipaddress.ip_address(self.ip) == ipaddress.ip_address(other.ip)
-
-    async def _get_ssh_connection(self) -> asyncssh.connect:
-        """Create a new asyncssh connection"""
-        try:
-            conn = await asyncssh.connect(
-                str(self.ip),
-                known_hosts=None,
-                username=self.uname,
-                password=self.pwd,
-                server_host_key_algs=["ssh-rsa"],
-            )
-            return conn
-        except asyncssh.misc.PermissionDenied:
-            try:
-                conn = await asyncssh.connect(
-                    str(self.ip),
-                    known_hosts=None,
-                    username="root",
-                    password="admin",
-                    server_host_key_algs=["ssh-rsa"],
-                )
-                return conn
-            except Exception as e:
-                raise e
-        except OSError as e:
-            logging.warning(f"Connection refused: {self}")
-            raise e
-        except Exception as e:
-            raise e
-
-    async def fault_light_on(self) -> bool:
-        return False
-
-    async def fault_light_off(self) -> bool:
-        return False
-
-    async def send_file(self, src, dest):
-        async with (await self._get_ssh_connection()) as conn:
-            await asyncssh.scp(src, (conn, dest))
-
-    async def check_light(self):
-        return self.light
-
-    async def get_board_info(self):
-        return None
-
-    async def get_config(self):
-        return None
-
-    async def get_hostname(self):
-        return None
-
-    async def get_model(self):
-        return None
-
-    async def reboot(self):
-        return False
-
-    async def restart_backend(self):
-        return False
-
-    async def send_config(self, *args, **kwargs):
-        return None
-
-    async def get_mac(self):
-        return None
-
-    async def get_data(self) -> MinerData:
-        return MinerData(ip=str(self.ip))
+# abstracted version of get miner that is easier to access
+async def get_miner(ip: Union[ipaddress.ip_address, str]) -> AnyMiner:
+    return await MinerFactory().get_miner(ip)

pyasic/miners/_backends/bmminer.py

@@ -18,9 +18,10 @@ from typing import Union
 
 
 from pyasic.API.bmminer import BMMinerAPI
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 from pyasic.data import MinerData
+from pyasic.config import MinerConfig
 
 from pyasic.settings import PyasicSettings
 
@@ -154,6 +155,29 @@ class BMMiner(BaseMiner):
             return True
         return False
 
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        return None
+
+    async def check_light(self) -> bool:
+        if not self.light:
+            self.light = False
+        return self.light
+
+    async def fault_light_off(self) -> bool:
+        return False
+
+    async def fault_light_on(self) -> bool:
+        return False
+
+    async def get_errors(self) -> list:
+        return []
+
+    async def get_mac(self) -> str:
+        return "00:00:00:00:00:00"
+
+    async def restart_backend(self) -> bool:
+        return False
+
     async def get_data(self) -> MinerData:
         """Get data from the miner.
 
@@ -168,6 +192,7 @@ class BMMiner(BaseMiner):
         model = await self.get_model()
         hostname = await self.get_hostname()
         mac = await self.get_mac()
+        errors = await self.get_errors()
 
         if model:
             data.model = model
@@ -178,6 +203,12 @@ class BMMiner(BaseMiner):
         if mac:
             data.mac = mac
 
+        if errors:
+            for error in errors:
+                data.errors.append(error)
+
+        data.fault_light = await self.check_light()
+
         miner_data = None
         for i in range(PyasicSettings().miner_get_data_retries):
             miner_data = await self.api.multicommand(
@@ -255,7 +286,8 @@ class BMMiner(BaseMiner):
                             env_temp = temp[1][f"temp_pcb{item}"].split("-")[0]
                             if not env_temp == 0:
                                 env_temp_list.append(int(env_temp))
-                    data.env_temp = sum(env_temp_list) / len(env_temp_list)
+                    if not env_temp_list == []:
+                        data.env_temp = sum(env_temp_list) / len(env_temp_list)
 
         if pools:
             pool_1 = None

pyasic/miners/_backends/bosminer.py

@@ -20,9 +20,9 @@ from typing import Union
 import toml
 
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 from pyasic.API.bosminer import BOSMinerAPI
-from pyasic.API import APIError
+from pyasic.errors import APIError
 
 from pyasic.data.error_codes import BraiinsOSError
 from pyasic.data import MinerData
@@ -72,11 +72,11 @@ class BOSMiner(BaseMiner):
     async def fault_light_on(self) -> bool:
         """Sends command to turn on fault light on the miner."""
         logging.debug(f"{self}: Sending fault_light on command.")
-        self.light = True
         _ret = await self.send_ssh_command("miner fault_light on")
         logging.debug(f"{self}: fault_light on command completed.")
         if isinstance(_ret, str):
-            return True
+            self.light = True
+            return self.light
         return False
 
     async def fault_light_off(self) -> bool:
@@ -86,6 +86,7 @@ class BOSMiner(BaseMiner):
         _ret = await self.send_ssh_command("miner fault_light off")
         logging.debug(f"{self}: fault_light off command completed.")
         if isinstance(_ret, str):
+            self.light = False
             return True
         return False
 
@@ -214,22 +215,12 @@ class BOSMiner(BaseMiner):
         logging.warning(f"Failed to get model for miner: {self}")
         return None
 
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
         """Configures miner with yaml config."""
         logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            toml_conf = (
-                MinerConfig()
-                .from_yaml(yaml_config)
-                .as_bos(model=self.model.replace(" (BOS)", ""), user_suffix=suffix)
-            )
-        else:
-            toml_conf = (
-                MinerConfig()
-                .from_yaml(yaml_config)
-                .as_bos(model=self.model.replace(" (BOS)", ""))
-            )
+        toml_conf = config.as_bos(
+            model=self.model.replace(" (BOS)", ""), user_suffix=user_suffix
+        )
         async with (await self._get_ssh_connection()) as conn:
             await conn.run("/etc/init.d/bosminer stop")
             logging.debug(f"{self}: Opening SFTP connection.")
@@ -240,6 +231,55 @@ class BOSMiner(BaseMiner):
             logging.debug(f"{self}: Restarting BOSMiner")
             await conn.run("/etc/init.d/bosminer start")
 
+    async def check_light(self) -> bool:
+        if self.light:
+            return self.light
+        data = (
+            await self.send_ssh_command("cat /sys/class/leds/'Red LED'/delay_off")
+        ).strip()
+        self.light = False
+        if data == "50":
+            self.light = True
+        return self.light
+
+    async def get_errors(self) -> list:
+        tunerstatus = None
+        errors = []
+
+        try:
+            tunerstatus = await self.api.tunerstatus()
+        except Exception as e:
+            logging.warning(e)
+
+        if tunerstatus:
+            tuner = tunerstatus[0].get("TUNERSTATUS")
+            if tuner:
+                if len(tuner) > 0:
+                    chain_status = tuner[0].get("TunerChainStatus")
+                    if chain_status and len(chain_status) > 0:
+                        board_map = {
+                            0: "Left board",
+                            1: "Center board",
+                            2: "Right board",
+                        }
+                        offset = (
+                            6
+                            if chain_status[0]["HashchainIndex"] in [6, 7, 8]
+                            else chain_status[0]["HashchainIndex"]
+                        )
+                        for board in chain_status:
+                            _id = board["HashchainIndex"] - offset
+                            if board["Status"] not in [
+                                "Stable",
+                                "Testing performance profile",
+                            ]:
+                                _error = board["Status"]
+                                _error = _error[0].lower() + _error[1:]
+                                errors.append(
+                                    BraiinsOSError(f"{board_map[_id]} {_error}")
+                                )
+        return errors
+
     async def get_data(self) -> MinerData:
         """Get data from the miner.
 
@@ -264,6 +304,8 @@ class BOSMiner(BaseMiner):
         if mac:
             data.mac = mac
 
+        data.fault_light = await self.check_light()
+
         miner_data = None
         for i in range(PyasicSettings().miner_get_data_retries):
             try:

pyasic/miners/_backends/bosminer_old.py

@@ -15,9 +15,12 @@
 import logging
 
 import ipaddress
+from typing import Union
 
 from pyasic.API.bosminer import BOSMinerAPI
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
+from pyasic.config import MinerConfig
+from pyasic.data import MinerData
 
 
 class BOSMinerOld(BaseMiner):
@@ -29,7 +32,7 @@ class BOSMinerOld(BaseMiner):
         self.uname = "root"
         self.pwd = "admin"
 
-    async def send_ssh_command(self, cmd: str) -> str or None:
+    async def send_ssh_command(self, cmd: str) -> Union[str, None]:
         """Send a command to the miner over ssh.
 
         :return: Result of the command or None.
@@ -61,3 +64,39 @@ class BOSMinerOld(BaseMiner):
     async def update_to_plus(self):
         result = await self.send_ssh_command("opkg update && opkg install bos_plus")
         return result
+
+    async def check_light(self) -> bool:
+        return False
+
+    async def fault_light_on(self) -> bool:
+        return False
+
+    async def fault_light_off(self) -> bool:
+        return False
+
+    async def get_config(self) -> None:
+        return None
+
+    async def get_errors(self) -> list:
+        return []
+
+    async def get_hostname(self) -> str:
+        return "?"
+
+    async def get_mac(self) -> str:
+        return "00:00:00:00:00:00"
+
+    async def get_model(self) -> str:
+        return "S9"
+
+    async def reboot(self) -> bool:
+        return False
+
+    async def restart_backend(self) -> bool:
+        return False
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        return None
+
+    async def get_data(self) -> MinerData:
+        return MinerData(ip=str(self.ip))

pyasic/miners/_backends/btminer.py

@@ -18,11 +18,12 @@ from typing import Union
 
 
 from pyasic.API.btminer import BTMinerAPI
-from pyasic.miners import BaseMiner
-from pyasic.API import APIError
+from pyasic.miners.base import BaseMiner
+from pyasic.errors import APIError
 
 from pyasic.data import MinerData
 from pyasic.data.error_codes import WhatsminerError
+from pyasic.config import MinerConfig
 
 from pyasic.settings import PyasicSettings
 
@@ -99,6 +100,100 @@ class BTMiner(BaseMiner):
 
         return str(mac).upper()
 
+    async def _reset_api_pwd_to_admin(self, pwd: str):
+        try:
+            data = await self.api.update_pwd(pwd, "admin")
+        except APIError:
+            return False
+        if data:
+            if "Code" in data.keys():
+                if data["Code"] == 131:
+                    return True
+        print(data)
+        return False
+
+    async def check_light(self) -> bool:
+        data = None
+
+        try:
+            data = await self.api.get_miner_info()
+        except APIError:
+            if not self.light:
+                self.light = False
+        if data:
+            if "Msg" in data.keys():
+                if "ledstat" in data["Msg"].keys():
+                    if not data["Msg"]["ledstat"] == "auto":
+                        self.light = True
+                    if data["Msg"]["ledstat"] == "auto":
+                        self.light = False
+        return self.light
+
+    async def fault_light_off(self) -> bool:
+        try:
+            data = await self.api.set_led(auto=True)
+        except APIError:
+            return False
+        if data:
+            if "Code" in data.keys():
+                if data["Code"] == 131:
+                    self.light = False
+                    return True
+        return False
+
+    async def fault_light_on(self) -> bool:
+        try:
+            data = await self.api.set_led(auto=False)
+            await self.api.set_led(
+                auto=False, color="green", start=0, period=1, duration=0
+            )
+        except APIError:
+            return False
+        if data:
+            if "Code" in data.keys():
+                if data["Code"] == 131:
+                    self.light = True
+                    return True
+        return False
+
+    async def get_errors(self) -> list:
+        return []
+
+    async def reboot(self) -> bool:
+        return False
+
+    async def restart_backend(self) -> bool:
+        return False
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        conf = config.as_wm(user_suffix=user_suffix)
+
+        await self.api.update_pools(
+            conf[0]["url"],
+            conf[0]["user"],
+            conf[0]["pass"],
+            conf[1]["url"],
+            conf[1]["user"],
+            conf[1]["pass"],
+            conf[2]["url"],
+            conf[2]["user"],
+            conf[2]["pass"],
+        )
+
+    async def get_config(self) -> MinerConfig:
+        pools = None
+        cfg = MinerConfig()
+
+        try:
+            pools = await self.api.pools()
+        except APIError as e:
+            logging.warning(e)
+
+        if pools:
+            if "POOLS" in pools.keys():
+                cfg = cfg.from_api(pools["POOLS"])
+        return cfg
+
     async def get_data(self) -> MinerData:
         """Get data from the miner.
 
@@ -129,6 +224,8 @@ class BTMiner(BaseMiner):
         if hostname:
             data.hostname = hostname
 
+        data.fault_light = await self.check_light()
+
         miner_data = None
         for i in range(PyasicSettings().miner_get_data_retries):
             try:

pyasic/miners/_backends/cgminer.py

@@ -18,8 +18,9 @@ from typing import Union
 
 
 from pyasic.API.cgminer import CGMinerAPI
-from pyasic.miners import BaseMiner
-from pyasic.API import APIError
+from pyasic.miners.base import BaseMiner
+from pyasic.errors import APIError
+from pyasic.config import MinerConfig
 
 from pyasic.data import MinerData
 
@@ -151,6 +152,26 @@ class CGMiner(BaseMiner):
             self.config = result.stdout
         return self.config
 
+    async def check_light(self) -> bool:
+        if not self.light:
+            self.light = False
+        return self.light
+
+    async def fault_light_off(self) -> bool:
+        return False
+
+    async def fault_light_on(self) -> bool:
+        return False
+
+    async def get_errors(self) -> list:
+        return []
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        return None
+
+    async def get_mac(self) -> str:
+        return "00:00:00:00:00:00"
+
     async def get_data(self) -> MinerData:
         """Get data from the miner.
 
@@ -175,6 +196,8 @@ class CGMiner(BaseMiner):
         if mac:
             data.mac = mac
 
+        data.fault_light = await self.check_light()
+
         miner_data = None
         for i in range(PyasicSettings().miner_get_data_retries):
             miner_data = await self.api.multicommand(

pyasic/miners/_types/__init__.py

@@ -15,3 +15,4 @@
 from .antminer import *
 from .avalonminer import *
 from .whatsminer import *
+from .innosilicon import *

pyasic/miners/_types/antminer/X17/S17.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S17(BaseMiner):

pyasic/miners/_types/antminer/X17/S17_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S17Plus(BaseMiner):

pyasic/miners/_types/antminer/X17/S17_Pro.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S17Pro(BaseMiner):

pyasic/miners/_types/antminer/X17/S17e.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S17e(BaseMiner):

pyasic/miners/_types/antminer/X17/T17.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class T17(BaseMiner):

pyasic/miners/_types/antminer/X17/T17_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class T17Plus(BaseMiner):

pyasic/miners/_types/antminer/X17/T17e.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class T17e(BaseMiner):

pyasic/miners/_types/antminer/X19/S19.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S19(BaseMiner):

pyasic/miners/_types/antminer/X19/S19_Pro.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S19Pro(BaseMiner):

pyasic/miners/_types/antminer/X19/S19a.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S19a(BaseMiner):

pyasic/miners/_types/antminer/X19/S19j.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S19j(BaseMiner):

pyasic/miners/_types/antminer/X19/S19j_Pro.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S19jPro(BaseMiner):

pyasic/miners/_types/antminer/X19/T19.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class T19(BaseMiner):

pyasic/miners/_types/antminer/X9/S9.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S9(BaseMiner):

pyasic/miners/_types/antminer/X9/S9i.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class S9i(BaseMiner):

pyasic/miners/_types/antminer/X9/T9.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class T9(BaseMiner):
@@ -20,5 +20,5 @@ class T9(BaseMiner):
         super().__init__()
         self.ip = ip
         self.model = "T9"
-        self.nominal_chips = 57
+        self.nominal_chips = 54
         self.fan_count = 2

pyasic/miners/_types/avalonminer/A10X/A1026.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon1026(BaseMiner):

pyasic/miners/_types/avalonminer/A10X/A1047.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon1047(BaseMiner):

pyasic/miners/_types/avalonminer/A10X/A1066.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon1066(BaseMiner):

pyasic/miners/_types/avalonminer/A7X/A721.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon721(BaseMiner):

pyasic/miners/_types/avalonminer/A7X/A741.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon741(BaseMiner):

pyasic/miners/_types/avalonminer/A7X/A761.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon761(BaseMiner):

pyasic/miners/_types/avalonminer/A8X/A821.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon821(BaseMiner):

pyasic/miners/_types/avalonminer/A8X/A841.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon841(BaseMiner):

pyasic/miners/_types/avalonminer/A8X/A851.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon851(BaseMiner):

pyasic/miners/_types/avalonminer/A9X/A921.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class Avalon921(BaseMiner):

pyasic/miners/_types/innosilicon/T3X/T3H_Plus.py

@@ -0,0 +1,24 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners.base import BaseMiner
+
+
+class InnosiliconT3HPlus(BaseMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__()
+        self.ip = ip
+        self.model = "T3H+"
+        self.nominal_chips = 114
+        self.fan_count = 4

pyasic/miners/_types/innosilicon/T3X/__init__.py

@@ -12,7 +12,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import unittest
-
-if __name__ == "__main__":
-    unittest.main()
+from .T3H_Plus import InnosiliconT3HPlus

pyasic/miners/_types/innosilicon/__init__.py

@@ -0,0 +1,15 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from .T3X import *

pyasic/miners/_types/whatsminer/M2X/M20.py

@@ -0,0 +1,33 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners.base import BaseMiner
+
+
+class M20(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M20"
+        self.nominal_chips = 70
+        self.fan_count = 2
+
+
+class M20V10(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M20 V10"
+        self.nominal_chips = 70
+        self.fan_count = 2

pyasic/miners/_types/whatsminer/M2X/M20S.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M20S(BaseMiner):
@@ -28,7 +28,7 @@ class M20SV10(BaseMiner):
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
-        self.model = "M20S"
+        self.model = "M20S V10"
         self.nominal_chips = 105
         self.fan_count = 2
 
@@ -37,6 +37,6 @@ class M20SV20(BaseMiner):
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
-        self.model = "M20S"
+        self.model = "M20S V20"
         self.nominal_chips = 111
         self.fan_count = 2

pyasic/miners/_types/whatsminer/M2X/M20S_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M20SPlus(BaseMiner):

pyasic/miners/_types/whatsminer/M2X/M21.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M21(BaseMiner):

pyasic/miners/_types/whatsminer/M2X/M21S.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M21S(BaseMiner):

pyasic/miners/_types/whatsminer/M2X/M21S_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M21SPlus(BaseMiner):

pyasic/miners/_types/whatsminer/M2X/__init__.py

@@ -12,6 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from .M20 import M20, M20V10
 from .M20S import M20S, M20SV10, M20SV20
 from .M20S_Plus import M20SPlus
 

pyasic/miners/_types/whatsminer/M3X/M30S.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M30S(BaseMiner):

pyasic/miners/_types/whatsminer/M3X/M30S_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M30SPlus(BaseMiner):

pyasic/miners/_types/whatsminer/M3X/M30S_Plus_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M30SPlusPlus(BaseMiner):
@@ -28,7 +28,7 @@ class M30SPlusPlusVG30(BaseMiner):
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
-        self.model = "M30S++ V30"
+        self.model = "M30S++ VG30"
         self.nominal_chips = 111
         self.fan_count = 2
 
@@ -37,6 +37,15 @@ class M30SPlusPlusVG40(BaseMiner):
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
-        self.model = "M30S++ V40"
+        self.model = "M30S++ VG40"
         self.nominal_chips = 117
         self.fan_count = 2
+
+
+class M30SPlusPlusVH60(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S++ VH60"
+        self.nominal_chips = 78
+        self.fan_count = 2

pyasic/miners/_types/whatsminer/M3X/M31S.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M31S(BaseMiner):

pyasic/miners/_types/whatsminer/M3X/M31S_Plus.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M31SPlus(BaseMiner):

pyasic/miners/_types/whatsminer/M3X/M32.py

@@ -0,0 +1,33 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners.base import BaseMiner
+
+
+class M32(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M32"
+        self.nominal_chips = 74
+        self.fan_count = 2
+
+
+class M32V20(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M32 V20"
+        self.nominal_chips = 74
+        self.fan_count = 2

pyasic/miners/_types/whatsminer/M3X/M32S.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners import BaseMiner
+from pyasic.miners.base import BaseMiner
 
 
 class M32S(BaseMiner):

pyasic/miners/_types/whatsminer/M3X/__init__.py

@@ -14,9 +14,15 @@
 
 from .M30S import M30S, M30SVE10, M30SVE20, M30SVG20, M30SV50
 from .M30S_Plus import M30SPlus, M30SPlusVG60, M30SPlusVE40, M30SPlusVF20
-from .M30S_Plus_Plus import M30SPlusPlus, M30SPlusPlusVG30, M30SPlusPlusVG40
+from .M30S_Plus_Plus import (
+    M30SPlusPlus,
+    M30SPlusPlusVG30,
+    M30SPlusPlusVG40,
+    M30SPlusPlusVH60,
+)
 
 from .M31S import M31S
 from .M31S_Plus import M31SPlus, M31SPlusVE20
 
+from .M32 import M32, M32V20
 from .M32S import M32S

pyasic/miners/antminer/bmminer/X17/X17.py

@@ -14,18 +14,23 @@
 
 from pyasic.miners._backends import BMMiner  # noqa - Ignore access to _module
 
+from pyasic.settings import PyasicSettings
+
 import httpx
+from typing import Union
 
 
 class BMMinerX17(BMMiner):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
+        self.uname = "root"
+        self.pwd = PyasicSettings().global_x17_password
 
-    async def get_hostname(self) -> str or None:
+    async def get_hostname(self) -> Union[str, None]:
         hostname = None
         url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:
@@ -35,10 +40,10 @@ class BMMinerX17(BMMiner):
                     hostname = data["hostname"]
         return hostname
 
-    async def get_mac(self):
+    async def get_mac(self) -> Union[str, None]:
         mac = None
         url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:
@@ -50,7 +55,7 @@ class BMMinerX17(BMMiner):
 
     async def fault_light_on(self) -> bool:
         url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             try:
                 await client.post(url, data={"action": "startBlink"}, auth=auth)
@@ -61,35 +66,43 @@ class BMMinerX17(BMMiner):
         if data.status_code == 200:
             data = data.json()
             if data["isBlinking"]:
+                self.light = True
                 return True
         return False
 
     async def fault_light_off(self) -> bool:
         url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             await client.post(url, data={"action": "stopBlink"}, auth=auth)
             data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
         if data.status_code == 200:
             data = data.json()
             if not data["isBlinking"]:
+                self.light = False
                 return True
         return False
 
-    async def check_light(self):
+    async def check_light(self) -> Union[bool, None]:
+        if self.light:
+            return self.light
         url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
         if data.status_code == 200:
             data = data.json()
             if data["isBlinking"]:
+                self.light = True
                 return True
-        return False
+            else:
+                self.light = False
+                return False
+        return None
 
     async def reboot(self) -> bool:
         url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:

pyasic/miners/antminer/bmminer/X19/X19.py

@@ -15,20 +15,39 @@
 from pyasic.miners._backends import BMMiner  # noqa - Ignore access to _module
 
 from pyasic.config import MinerConfig
+from pyasic.data.error_codes import X19Error
+from pyasic.settings import PyasicSettings
 
 import httpx
 import json
 import asyncio
+from typing import Union, List
 
 
 class BMMinerX19(BMMiner):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
+        self.uname = "root"
+        self.pwd = PyasicSettings().global_x19_password
+
+    async def check_light(self) -> Union[bool, None]:
+        if self.light:
+            return self.light
+        url = f"http://{self.ip}/cgi-bin/get_blink_status.cgi"
+        auth = httpx.DigestAuth(self.uname, self.pwd)
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            light = data["blink"]
+            self.light = light
+            return light
+        return None
 
     async def get_config(self) -> MinerConfig:
         url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:
@@ -36,14 +55,10 @@ class BMMinerX19(BMMiner):
             self.config = MinerConfig().from_raw(data)
         return self.config
 
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
         url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
+        auth = httpx.DigestAuth(self.uname, self.pwd)
+        conf = config.as_x19(user_suffix=user_suffix)
 
         try:
             async with httpx.AsyncClient() as client:
@@ -56,10 +71,10 @@ class BMMinerX19(BMMiner):
                 break
             await asyncio.sleep(1)
 
-    async def get_hostname(self) -> str or None:
+    async def get_hostname(self) -> Union[str, None]:
         hostname = None
         url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:
@@ -69,10 +84,10 @@ class BMMinerX19(BMMiner):
                     hostname = data["hostname"]
         return hostname
 
-    async def get_mac(self):
+    async def get_mac(self) -> Union[str, None]:
         mac = None
         url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:
@@ -84,33 +99,50 @@ class BMMinerX19(BMMiner):
 
     async def fault_light_on(self) -> bool:
         url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         data = json.dumps({"blink": "true"})
         async with httpx.AsyncClient() as client:
             data = await client.post(url, data=data, auth=auth)
         if data.status_code == 200:
             data = data.json()
             if data.get("code") == "B000":
+                self.light = True
                 return True
         return False
 
     async def fault_light_off(self) -> bool:
         url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         data = json.dumps({"blink": "false"})
         async with httpx.AsyncClient() as client:
             data = await client.post(url, data=data, auth=auth)
         if data.status_code == 200:
             data = data.json()
             if data.get("code") == "B100":
+                self.light = False
                 return True
         return False
 
     async def reboot(self) -> bool:
         url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         async with httpx.AsyncClient() as client:
             data = await client.get(url, auth=auth)
         if data.status_code == 200:
             return True
         return False
+
+    async def get_errors(self) -> List[X19Error]:
+        errors = []
+        url = f"http://{self.ip}/cgi-bin/summary.cgi"
+        auth = httpx.DigestAuth(self.uname, self.pwd)
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data:
+            data = data.json()
+            if "SUMMARY" in data.keys():
+                if "status" in data["SUMMARY"][0].keys():
+                    for item in data["SUMMARY"][0]["status"]:
+                        if not item["status"] == "s":
+                            errors.append(X19Error(item["msg"]))
+        return errors

pyasic/miners/antminer/cgminer/X9/__init__.py

@@ -13,3 +13,4 @@
 #  limitations under the License.
 
 from .S9 import CGMinerS9
+from .T9 import CGMinerT9

pyasic/miners/antminer/hiveon/X9/T9.py

@@ -15,8 +15,180 @@
 from pyasic.miners._backends import Hiveon  # noqa - Ignore access to _module
 from pyasic.miners._types import T9  # noqa - Ignore access to _module
 
+from pyasic.data import MinerData
+from pyasic.settings import PyasicSettings
+
 
 class HiveonT9(Hiveon, T9):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
+        self.pwd = "admin"
+
+    async def get_mac(self):
+        mac = (
+            (await self.send_ssh_command("cat /sys/class/net/eth0/address"))
+            .strip()
+            .upper()
+        )
+        return mac
+
+    async def get_data(self) -> MinerData:
+        """Get data from the miner.
+
+        Returns:
+            A [`MinerData`][pyasic.data.MinerData] instance containing the miners data.
+        """
+        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
+
+        board_offset = -1
+        fan_offset = -1
+
+        model = await self.get_model()
+        hostname = await self.get_hostname()
+        mac = await self.get_mac()
+        errors = await self.get_errors()
+
+        if model:
+            data.model = model
+
+        if hostname:
+            data.hostname = hostname
+
+        if mac:
+            data.mac = mac
+
+        if errors:
+            for error in errors:
+                data.errors.append(error)
+
+        data.fault_light = await self.check_light()
+
+        miner_data = None
+        for i in range(PyasicSettings().miner_get_data_retries):
+            miner_data = await self.api.multicommand(
+                "summary", "pools", "stats", ignore_x19_error=True
+            )
+            if miner_data:
+                break
+
+        if not miner_data:
+            return data
+
+        summary = miner_data.get("summary")[0]
+        pools = miner_data.get("pools")[0]
+        stats = miner_data.get("stats")[0]
+
+        if summary:
+            hr = summary.get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("GHS 1m")
+                    if hr:
+                        data.hashrate = round(hr / 1000, 2)
+
+        if stats:
+            boards = stats.get("STATS")
+            if boards:
+                if len(boards) > 0:
+                    if "chain_power" in boards[1].keys():
+                        data.wattage = round(
+                            float(boards[1]["chain_power"].split(" ")[0])
+                        )
+
+                    board_map = {
+                        "left": [2, 9, 10],
+                        "center": [3, 11, 12],
+                        "right": [4, 13, 14],
+                    }
+
+                    env_temp_list = []
+
+                    for board in board_map.keys():
+                        chips = 0
+                        hashrate = 0
+                        chip_temp = 0
+                        board_temp = 0
+                        for chipset in board_map[board]:
+                            if chip_temp == 0:
+                                if f"temp{chipset}" in boards[1].keys():
+                                    board_temp = boards[1][f"temp{chipset}"]
+                                    chip_temp = boards[1][f"temp2_{chipset}"]
+                                    if f"temp3_{chipset}" in boards[1].keys():
+                                        env_temp = boards[1][f"temp3_{chipset}"]
+                                        if not env_temp == 0:
+                                            env_temp_list.append(int(env_temp))
+
+                            hashrate += boards[1][f"chain_rate{chipset}"]
+                            chips += boards[1][f"chain_acn{chipset}"]
+                        setattr(data, f"{board}_chips", chips)
+                        setattr(data, f"{board}_board_hashrate", hashrate)
+                        setattr(data, f"{board}_board_temp", board_temp)
+                        setattr(data, f"{board}_board_chip_temp", chip_temp)
+                    if not env_temp_list == []:
+                        data.env_temp = sum(env_temp_list) / len(env_temp_list)
+
+        if stats:
+            temp = stats.get("STATS")
+            if temp:
+                if len(temp) > 1:
+                    for fan_num in range(1, 8, 4):
+                        for _f_num in range(4):
+                            f = temp[1].get(f"fan{fan_num + _f_num}")
+                            if f and not f == 0 and fan_offset == -1:
+                                fan_offset = fan_num
+                    if fan_offset == -1:
+                        fan_offset = 1
+                    for fan in range(self.fan_count):
+                        setattr(
+                            data, f"fan_{fan + 1}", temp[1].get(f"fan{fan_offset+fan}")
+                        )
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools.get("POOLS"):
+                if not pool.get("User") == "*":
+                    if not pool_1_user:
+                        pool_1_user = pool.get("User")
+                        pool_1 = pool["URL"]
+                        pool_1_quota = pool["Quota"]
+                    elif not pool_2_user:
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+                    if not pool.get("User") == pool_1_user:
+                        if not pool_2_user == pool.get("User"):
+                            pool_2_user = pool.get("User")
+                            pool_2 = pool["URL"]
+                            pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_1_url = pool_1
+
+            if pool_1_user:
+                data.pool_1_user = pool_1_user
+
+            if pool_2:
+                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_2_url = pool_2
+
+            if pool_2_user:
+                data.pool_2_user = pool_2_user
+
+            if quota:
+                data.pool_split = str(quota)
+
+        return data

pyasic/miners/avalonminer/cgminer/A10X/A1026.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A10X import CGMinerA10X
 from pyasic.miners._types import Avalon1026  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon1026(CGMiner, Avalon1026):
+class CGMinerAvalon1026(CGMinerA10X, Avalon1026):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A10X/A1047.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A10X import CGMinerA10X
 from pyasic.miners._types import Avalon1047  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon1047(CGMiner, Avalon1047):
+class CGMinerAvalon1047(CGMinerA10X, Avalon1047):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A10X/A1066.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A10X import CGMinerA10X
 from pyasic.miners._types import Avalon1066  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon1066(CGMiner, Avalon1066):
+class CGMinerAvalon1066(CGMinerA10X, Avalon1066):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A10X/A10X.py

@@ -0,0 +1,257 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+
+from pyasic.data import MinerData
+from pyasic.settings import PyasicSettings
+import re
+from pyasic.config import MinerConfig
+import logging
+
+
+class CGMinerA10X(CGMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def check_light(self) -> bool:
+        if self.light:
+            return self.light
+        data = await self.api.ascset(0, "led", "1-255")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set info: LED[1]":
+            return True
+        return False
+
+    async def fault_light_on(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-1")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def fault_light_off(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-0")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def reboot(self) -> bool:
+        if (await self.api.restart())["STATUS"] == "RESTART":
+            return True
+        return False
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        """Configures miner with yaml config."""
+        raise NotImplementedError
+        logging.debug(f"{self}: Sending config.")
+        conf = config.as_avalon(user_suffix=user_suffix)
+        data = await self.api.ascset(
+            0, "setpool", f"root,root,{conf}"
+        )  # this should work but doesn't
+        return data
+
+    async def get_mac(self) -> str:
+        mac = None
+        version = await self.api.version()
+        if version:
+            if "VERSION" in version.keys():
+                if "MAC" in version["VERSION"][0].keys():
+                    base_mac = version["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+        return mac
+
+    async def get_data(self):
+        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
+
+        model = await self.get_model()
+        mac = None
+
+        if model:
+            data.model = model
+
+        miner_data = None
+        for i in range(PyasicSettings().miner_get_data_retries):
+            miner_data = await self.api.multicommand(
+                "version", "summary", "pools", "stats"
+            )
+            if miner_data:
+                break
+        if not miner_data:
+            hostname = await self.get_hostname()
+            mac = await self.get_mac()
+
+            if hostname and not hostname == "?":
+                data.hostname = hostname
+            elif mac:
+                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+            if mac:
+                data.mac = mac
+            return data
+
+        data.fault_light = await self.check_light()
+
+        summary = miner_data.get("summary")
+        version = miner_data.get("version")
+        pools = miner_data.get("pools")
+        stats = miner_data.get("stats")
+
+        if summary:
+            hr = summary[0].get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("MHS 1m")
+                    if hr:
+                        data.hashrate = round(hr / 1000000, 2)
+
+        if version:
+            if "VERSION" in version[0].keys():
+                if "MAC" in version[0]["VERSION"][0].keys():
+                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+
+        if stats:
+            stats_data = stats[0].get("STATS")
+            if stats_data:
+                for key in stats_data[0].keys():
+                    if key.startswith("MM ID"):
+                        raw_data = self.parse_stats(stats_data[0][key])
+                        for fan in range(self.fan_count):
+                            if f"Fan{fan+1}" in raw_data:
+                                setattr(
+                                    data,
+                                    f"fan_{fan+1}",
+                                    int(raw_data[f"Fan{fan+1}"]),
+                                )
+                            if "MTmax" in raw_data.keys():
+                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
+                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
+                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
+                            if "MTavg" in raw_data.keys():
+                                data.left_board_temp = int(raw_data["MTavg"][0])
+                                data.center_board_temp = int(raw_data["MTavg"][1])
+                                data.right_board_temp = int(raw_data["MTavg"][2])
+
+                        if "PVT_T0" in raw_data:
+                            data.left_chips = len(
+                                [item for item in raw_data["PVT_T0"] if not item == "0"]
+                            )
+                        if "PVT_T1" in raw_data:
+                            data.center_chips = len(
+                                [item for item in raw_data["PVT_T1"] if not item == "0"]
+                            )
+                        if "PVT_T2" in raw_data:
+                            data.right_chips = len(
+                                [item for item in raw_data["PVT_T2"] if not item == "0"]
+                            )
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools[0].get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_1_url = pool_1
+
+            if pool_1_user:
+                data.pool_1_user = pool_1_user
+
+            if pool_2:
+                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_2_url = pool_2
+
+            if pool_2_user:
+                data.pool_2_user = pool_2_user
+
+            if quota:
+                data.pool_split = str(quota)
+
+        hostname = await self.get_hostname()
+
+        if mac:
+            data.mac = mac
+        else:
+            mac = await self.get_mac()
+            if mac:
+                data.mac = mac
+        if hostname and not hostname == "?":
+            data.hostname = hostname
+        elif mac:
+            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+
+        return data
+
+    @staticmethod
+    def parse_stats(stats):
+        _stats_items = re.findall(".+?\[*?]", stats)
+        stats_items = []
+        stats_dict = {}
+        for item in _stats_items:
+            if ":" in item:
+                data = item.replace("]", "").split("[")
+                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
+                data_dict = {}
+                for key, val in [tuple(item) for item in data_list]:
+                    data_dict[key] = val
+                raw_data = [data[0].strip(), data_dict]
+            else:
+                raw_data = [
+                    value
+                    for value in item.replace("[", " ")
+                    .replace("]", " ")
+                    .split(" ")[:-1]
+                    if value != ""
+                ]
+                if len(raw_data) == 1:
+                    raw_data.append("")
+            if raw_data[0] == "":
+                raw_data = raw_data[1:]
+
+            if len(raw_data) == 2:
+                stats_dict[raw_data[0]] = raw_data[1]
+            else:
+                stats_dict[raw_data[0]] = raw_data[1:]
+            stats_items.append(raw_data)
+
+        return stats_dict

pyasic/miners/avalonminer/cgminer/A7X/A721.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A7X import CGMinerA7X  # noqa - Ignore access to _module
 from pyasic.miners._types import Avalon721  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon721(CGMiner, Avalon721):
+class CGMinerAvalon721(CGMinerA7X, Avalon721):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A7X/A741.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A7X import CGMinerA7X  # noqa - Ignore access to _module
 from pyasic.miners._types import Avalon741  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon741(CGMiner, Avalon741):
+class CGMinerAvalon741(CGMinerA7X, Avalon741):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A7X/A761.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A7X import CGMinerA7X  # noqa - Ignore access to _module
 from pyasic.miners._types import Avalon761  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon761(CGMiner, Avalon761):
+class CGMinerAvalon761(CGMinerA7X, Avalon761):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A7X/A7X.py

@@ -0,0 +1,257 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+
+from pyasic.data import MinerData
+from pyasic.settings import PyasicSettings
+import re
+from pyasic.config import MinerConfig
+import logging
+
+
+class CGMinerA7X(CGMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def check_light(self) -> bool:
+        if self.light:
+            return self.light
+        data = await self.api.ascset(0, "led", "1-255")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set info: LED[1]":
+            return True
+        return False
+
+    async def fault_light_on(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-1")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def fault_light_off(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-0")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def reboot(self) -> bool:
+        if (await self.api.restart())["STATUS"] == "RESTART":
+            return True
+        return False
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        """Configures miner with yaml config."""
+        raise NotImplementedError
+        logging.debug(f"{self}: Sending config.")
+        conf = config.as_avalon(user_suffix=user_suffix)
+        data = await self.api.ascset(
+            0, "setpool", f"root,root,{conf}"
+        )  # this should work but doesn't
+        return data
+
+    async def get_mac(self) -> str:
+        mac = None
+        version = await self.api.version()
+        if version:
+            if "VERSION" in version.keys():
+                if "MAC" in version["VERSION"][0].keys():
+                    base_mac = version["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+        return mac
+
+    async def get_data(self):
+        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
+
+        model = await self.get_model()
+        mac = None
+
+        if model:
+            data.model = model
+
+        miner_data = None
+        for i in range(PyasicSettings().miner_get_data_retries):
+            miner_data = await self.api.multicommand(
+                "version", "summary", "pools", "stats"
+            )
+            if miner_data:
+                break
+        if not miner_data:
+            hostname = await self.get_hostname()
+            mac = await self.get_mac()
+
+            if hostname and not hostname == "?":
+                data.hostname = hostname
+            elif mac:
+                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+            if mac:
+                data.mac = mac
+            return data
+
+        data.fault_light = await self.check_light()
+
+        summary = miner_data.get("summary")
+        version = miner_data.get("version")
+        pools = miner_data.get("pools")
+        stats = miner_data.get("stats")
+
+        if summary:
+            hr = summary[0].get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("MHS 1m")
+                    if hr:
+                        data.hashrate = round(hr / 1000000, 2)
+
+        if version:
+            if "VERSION" in version[0].keys():
+                if "MAC" in version[0]["VERSION"][0].keys():
+                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+
+        if stats:
+            stats_data = stats[0].get("STATS")
+            if stats_data:
+                for key in stats_data[0].keys():
+                    if key.startswith("MM ID"):
+                        raw_data = self.parse_stats(stats_data[0][key])
+                        for fan in range(self.fan_count):
+                            if f"Fan{fan+1}" in raw_data:
+                                setattr(
+                                    data,
+                                    f"fan_{fan+1}",
+                                    int(raw_data[f"Fan{fan+1}"]),
+                                )
+                            if "MTmax" in raw_data.keys():
+                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
+                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
+                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
+                            if "MTavg" in raw_data.keys():
+                                data.left_board_temp = int(raw_data["MTavg"][0])
+                                data.center_board_temp = int(raw_data["MTavg"][1])
+                                data.right_board_temp = int(raw_data["MTavg"][2])
+
+                        if "PVT_T0" in raw_data:
+                            data.left_chips = len(
+                                [item for item in raw_data["PVT_T0"] if not item == "0"]
+                            )
+                        if "PVT_T1" in raw_data:
+                            data.center_chips = len(
+                                [item for item in raw_data["PVT_T1"] if not item == "0"]
+                            )
+                        if "PVT_T2" in raw_data:
+                            data.right_chips = len(
+                                [item for item in raw_data["PVT_T2"] if not item == "0"]
+                            )
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools[0].get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_1_url = pool_1
+
+            if pool_1_user:
+                data.pool_1_user = pool_1_user
+
+            if pool_2:
+                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_2_url = pool_2
+
+            if pool_2_user:
+                data.pool_2_user = pool_2_user
+
+            if quota:
+                data.pool_split = str(quota)
+
+        hostname = await self.get_hostname()
+
+        if mac:
+            data.mac = mac
+        else:
+            mac = await self.get_mac()
+            if mac:
+                data.mac = mac
+        if hostname and not hostname == "?":
+            data.hostname = hostname
+        elif mac:
+            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+
+        return data
+
+    @staticmethod
+    def parse_stats(stats):
+        _stats_items = re.findall(".+?\[*?]", stats)
+        stats_items = []
+        stats_dict = {}
+        for item in _stats_items:
+            if ":" in item:
+                data = item.replace("]", "").split("[")
+                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
+                data_dict = {}
+                for key, val in [tuple(item) for item in data_list]:
+                    data_dict[key] = val
+                raw_data = [data[0].strip(), data_dict]
+            else:
+                raw_data = [
+                    value
+                    for value in item.replace("[", " ")
+                    .replace("]", " ")
+                    .split(" ")[:-1]
+                    if value != ""
+                ]
+                if len(raw_data) == 1:
+                    raw_data.append("")
+            if raw_data[0] == "":
+                raw_data = raw_data[1:]
+
+            if len(raw_data) == 2:
+                stats_dict[raw_data[0]] = raw_data[1]
+            else:
+                stats_dict[raw_data[0]] = raw_data[1:]
+            stats_items.append(raw_data)
+
+        return stats_dict

pyasic/miners/avalonminer/cgminer/A8X/A821.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A8X import CGMinerA8X  # noqa - Ignore access to _module
 from pyasic.miners._types import Avalon821  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon821(CGMiner, Avalon821):
+class CGMinerAvalon821(CGMinerA8X, Avalon821):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A8X/A841.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A8X import CGMinerA8X  # noqa - Ignore access to _module
 from pyasic.miners._types import Avalon841  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon841(CGMiner, Avalon841):
+class CGMinerAvalon841(CGMinerA8X, Avalon841):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname:
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A8X/A851.py

@@ -12,241 +12,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+from .A8X import CGMinerA8X  # noqa - Ignore access to _module
 from pyasic.miners._types import Avalon851  # noqa - Ignore access to _module
 
-from pyasic.data import MinerData
-from pyasic.settings import PyasicSettings
-import re
-from pyasic.config import MinerConfig
-import logging
 
-
-class CGMinerAvalon851(CGMiner, Avalon851):
+class CGMinerAvalon851(CGMinerA8X, Avalon851):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def fault_light_on(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-1")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        data = await self.api.ascset(0, "led", "1-0")
-        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        if (await self.api.restart())["STATUS"] == "RESTART":
-            return True
-        return False
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        raise NotImplementedError
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
-        data = await self.api.ascset(
-            0, "setpool", f"root,root,{conf}"
-        )  # this should work but doesn't
-        return data
-
-    async def get_mac(self) -> str:
-        mac = None
-        version = await self.api.version()
-        if version:
-            if "VERSION" in version.keys():
-                if "MAC" in version["VERSION"][0].keys():
-                    base_mac = version["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-        return mac
-
-    async def get_data(self):
-        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
-
-        model = await self.get_model()
-        mac = None
-
-        if model:
-            data.model = model
-
-        miner_data = None
-        for i in range(PyasicSettings().miner_get_data_retries):
-            miner_data = await self.api.multicommand(
-                "version", "summary", "pools", "stats"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            hostname = await self.get_hostname()
-            mac = await self.get_mac()
-
-            if hostname and not hostname == "?":
-                data.hostname = hostname
-            elif mac:
-                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-            if mac:
-                data.mac = mac
-            return data
-
-        summary = miner_data.get("summary")
-        version = miner_data.get("version")
-        pools = miner_data.get("pools")
-        stats = miner_data.get("stats")
-
-        if summary:
-            hr = summary[0].get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS 1m")
-                    if hr:
-                        data.hashrate = round(hr / 1000000, 2)
-
-        if version:
-            if "VERSION" in version[0].keys():
-                if "MAC" in version[0]["VERSION"][0].keys():
-                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
-                    # parse the MAC into a recognizable form
-                    mac = ":".join(
-                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
-                    )
-
-        if stats:
-            stats_data = stats[0].get("STATS")
-            if stats_data:
-                for key in stats_data[0].keys():
-                    if key.startswith("MM ID"):
-                        raw_data = self.parse_stats(stats_data[0][key])
-                        for fan in range(self.fan_count):
-                            if f"Fan{fan+1}" in raw_data:
-                                setattr(
-                                    data,
-                                    f"fan_{fan+1}",
-                                    int(raw_data[f"Fan{fan+1}"]),
-                                )
-                            if "MTmax" in raw_data.keys():
-                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
-                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
-                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
-                            if "MTavg" in raw_data.keys():
-                                data.left_board_temp = int(raw_data["MTavg"][0])
-                                data.center_board_temp = int(raw_data["MTavg"][1])
-                                data.right_board_temp = int(raw_data["MTavg"][2])
-
-                        if "PVT_T0" in raw_data:
-                            data.left_chips = len(
-                                [item for item in raw_data["PVT_T0"] if not item == "0"]
-                            )
-                        if "PVT_T1" in raw_data:
-                            data.center_chips = len(
-                                [item for item in raw_data["PVT_T1"] if not item == "0"]
-                            )
-                        if "PVT_T2" in raw_data:
-                            data.right_chips = len(
-                                [item for item in raw_data["PVT_T2"] if not item == "0"]
-                            )
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools[0].get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_1_url = pool_1
-
-            if pool_1_user:
-                data.pool_1_user = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
-                    "stratum2+tcp://", ""
-                )
-                data.pool_2_url = pool_2
-
-            if pool_2_user:
-                data.pool_2_user = pool_2_user
-
-            if quota:
-                data.pool_split = str(quota)
-
-        hostname = await self.get_hostname()
-
-        if mac:
-            data.mac = mac
-        else:
-            mac = await self.get_mac()
-            if mac:
-                data.mac = mac
-        if hostname and not hostname == "?":
-            data.hostname = hostname
-        elif mac:
-            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
-
-        return data
-
-    @staticmethod
-    def parse_stats(stats):
-        _stats_items = re.findall(".+?\[*?]", stats)
-        stats_items = []
-        stats_dict = {}
-        for item in _stats_items:
-            if ":" in item:
-                data = item.replace("]", "").split("[")
-                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
-                data_dict = {}
-                for key, val in [tuple(item) for item in data_list]:
-                    data_dict[key] = val
-                raw_data = [data[0].strip(), data_dict]
-            else:
-                raw_data = [
-                    value
-                    for value in item.replace("[", " ")
-                    .replace("]", " ")
-                    .split(" ")[:-1]
-                    if value != ""
-                ]
-                if len(raw_data) == 1:
-                    raw_data.append("")
-            if raw_data[0] == "":
-                raw_data = raw_data[1:]
-
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
-            stats_items.append(raw_data)
-
-        return stats_dict

pyasic/miners/avalonminer/cgminer/A8X/A8X.py

@@ -0,0 +1,257 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners._backends import CGMiner  # noqa - Ignore access to _module
+
+from pyasic.data import MinerData
+from pyasic.settings import PyasicSettings
+import re
+from pyasic.config import MinerConfig
+import logging
+
+
+class CGMinerA8X(CGMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def check_light(self) -> bool:
+        if self.light:
+            return self.light
+        data = await self.api.ascset(0, "led", "1-255")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set info: LED[1]":
+            return True
+        return False
+
+    async def fault_light_on(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-1")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def fault_light_off(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-0")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def reboot(self) -> bool:
+        if (await self.api.restart())["STATUS"] == "RESTART":
+            return True
+        return False
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        """Configures miner with yaml config."""
+        raise NotImplementedError
+        logging.debug(f"{self}: Sending config.")
+        conf = config.as_avalon(user_suffix=user_suffix)
+        data = await self.api.ascset(
+            0, "setpool", f"root,root,{conf}"
+        )  # this should work but doesn't
+        return data
+
+    async def get_mac(self) -> str:
+        mac = None
+        version = await self.api.version()
+        if version:
+            if "VERSION" in version.keys():
+                if "MAC" in version["VERSION"][0].keys():
+                    base_mac = version["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+        return mac
+
+    async def get_data(self):
+        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
+
+        model = await self.get_model()
+        mac = None
+
+        if model:
+            data.model = model
+
+        miner_data = None
+        for i in range(PyasicSettings().miner_get_data_retries):
+            miner_data = await self.api.multicommand(
+                "version", "summary", "pools", "stats"
+            )
+            if miner_data:
+                break
+        if not miner_data:
+            hostname = await self.get_hostname()
+            mac = await self.get_mac()
+
+            if hostname and not hostname == "?":
+                data.hostname = hostname
+            elif mac:
+                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+            if mac:
+                data.mac = mac
+            return data
+
+        data.fault_light = await self.check_light()
+
+        summary = miner_data.get("summary")
+        version = miner_data.get("version")
+        pools = miner_data.get("pools")
+        stats = miner_data.get("stats")
+
+        if summary:
+            hr = summary[0].get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("MHS 1m")
+                    if hr:
+                        data.hashrate = round(hr / 1000000, 2)
+
+        if version:
+            if "VERSION" in version[0].keys():
+                if "MAC" in version[0]["VERSION"][0].keys():
+                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+
+        if stats:
+            stats_data = stats[0].get("STATS")
+            if stats_data:
+                for key in stats_data[0].keys():
+                    if key.startswith("MM ID"):
+                        raw_data = self.parse_stats(stats_data[0][key])
+                        for fan in range(self.fan_count):
+                            if f"Fan{fan+1}" in raw_data:
+                                setattr(
+                                    data,
+                                    f"fan_{fan+1}",
+                                    int(raw_data[f"Fan{fan+1}"]),
+                                )
+                            if "MTmax" in raw_data.keys():
+                                data.left_board_chip_temp = int(raw_data["MTmax"][0])
+                                data.center_board_chip_temp = int(raw_data["MTmax"][1])
+                                data.right_board_chip_temp = int(raw_data["MTmax"][2])
+                            if "MTavg" in raw_data.keys():
+                                data.left_board_temp = int(raw_data["MTavg"][0])
+                                data.center_board_temp = int(raw_data["MTavg"][1])
+                                data.right_board_temp = int(raw_data["MTavg"][2])
+
+                        if "PVT_T0" in raw_data:
+                            data.left_chips = len(
+                                [item for item in raw_data["PVT_T0"] if not item == "0"]
+                            )
+                        if "PVT_T1" in raw_data:
+                            data.center_chips = len(
+                                [item for item in raw_data["PVT_T1"] if not item == "0"]
+                            )
+                        if "PVT_T2" in raw_data:
+                            data.right_chips = len(
+                                [item for item in raw_data["PVT_T2"] if not item == "0"]
+                            )
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools[0].get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_1_url = pool_1
+
+            if pool_1_user:
+                data.pool_1_user = pool_1_user
+
+            if pool_2:
+                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_2_url = pool_2
+
+            if pool_2_user:
+                data.pool_2_user = pool_2_user
+
+            if quota:
+                data.pool_split = str(quota)
+
+        hostname = await self.get_hostname()
+
+        if mac:
+            data.mac = mac
+        else:
+            mac = await self.get_mac()
+            if mac:
+                data.mac = mac
+        if hostname and not hostname == "?":
+            data.hostname = hostname
+        elif mac:
+            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+
+        return data
+
+    @staticmethod
+    def parse_stats(stats):
+        _stats_items = re.findall(".+?\[*?]", stats)
+        stats_items = []
+        stats_dict = {}
+        for item in _stats_items:
+            if ":" in item:
+                data = item.replace("]", "").split("[")
+                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
+                data_dict = {}
+                for key, val in [tuple(item) for item in data_list]:
+                    data_dict[key] = val
+                raw_data = [data[0].strip(), data_dict]
+            else:
+                raw_data = [
+                    value
+                    for value in item.replace("[", " ")
+                    .replace("]", " ")
+                    .split(" ")[:-1]
+                    if value != ""
+                ]
+                if len(raw_data) == 1:
+                    raw_data.append("")
+            if raw_data[0] == "":
+                raw_data = raw_data[1:]
+
+            if len(raw_data) == 2:
+                stats_dict[raw_data[0]] = raw_data[1]
+            else:
+                stats_dict[raw_data[0]] = raw_data[1:]
+            stats_items.append(raw_data)
+
+        return stats_dict

pyasic/miners/avalonminer/cgminer/A9X/A921.py

@@ -27,6 +27,14 @@ class CGMinerAvalon921(CGMiner, Avalon921):
         super().__init__(ip)
         self.ip = ip
 
+    async def check_light(self) -> bool:
+        if self.light:
+            return self.light
+        data = await self.api.ascset(0, "led", "1-255")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set info: LED[1]":
+            return True
+        return False
+
     async def fault_light_on(self) -> bool:
         data = await self.api.ascset(0, "led", "1-1")
         if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
@@ -44,15 +52,11 @@ class CGMinerAvalon921(CGMiner, Avalon921):
             return True
         return False
 
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
         """Configures miner with yaml config."""
         raise NotImplementedError
         logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_avalon()
+        conf = config.as_avalon(user_suffix=user_suffix)
         data = await self.api.ascset(
             0, "setpool", f"root,root,{conf}"
         )  # this should work but doesn't
@@ -80,6 +84,8 @@ class CGMinerAvalon921(CGMiner, Avalon921):
         if model:
             data.model = model
 
+        data.fault_light = await self.check_light()
+
         miner_data = None
         for i in range(PyasicSettings().miner_get_data_retries):
             miner_data = await self.api.multicommand(

pyasic/miners/base.py

@@ -0,0 +1,204 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import asyncssh
+import logging
+import ipaddress
+from abc import ABC, abstractmethod
+from typing import TypeVar, List, Union
+
+from pyasic.data import MinerData
+from pyasic.config import MinerConfig
+from pyasic.data.error_codes import (
+    WhatsminerError,
+    BraiinsOSError,
+    InnosiliconError,
+    X19Error,
+)
+
+
+class BaseMiner(ABC):
+    def __init__(self, *args) -> None:
+        self.ip = None
+        self.uname = "root"
+        self.pwd = "admin"
+        self.api = None
+        self.api_type = None
+        self.model = None
+        self.light = None
+        self.hostname = None
+        self.nominal_chips = 1
+        self.version = None
+        self.fan_count = 2
+        self.config = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls is BaseMiner:
+            raise TypeError(f"Only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls)
+
+    def __repr__(self):
+        return f"{'' if not self.api_type else self.api_type} {'' if not self.model else self.model}: {str(self.ip)}"
+
+    def __lt__(self, other):
+        return ipaddress.ip_address(self.ip) < ipaddress.ip_address(other.ip)
+
+    def __gt__(self, other):
+        return ipaddress.ip_address(self.ip) > ipaddress.ip_address(other.ip)
+
+    def __eq__(self, other):
+        return ipaddress.ip_address(self.ip) == ipaddress.ip_address(other.ip)
+
+    async def _get_ssh_connection(self) -> asyncssh.connect:
+        """Create a new asyncssh connection"""
+        try:
+            conn = await asyncssh.connect(
+                str(self.ip),
+                known_hosts=None,
+                username=self.uname,
+                password=self.pwd,
+                server_host_key_algs=["ssh-rsa"],
+            )
+            return conn
+        except asyncssh.misc.PermissionDenied:
+            try:
+                conn = await asyncssh.connect(
+                    str(self.ip),
+                    known_hosts=None,
+                    username="root",
+                    password="admin",
+                    server_host_key_algs=["ssh-rsa"],
+                )
+                return conn
+            except Exception as e:
+                raise e
+        except OSError as e:
+            logging.warning(f"Connection refused: {self}")
+            raise e
+        except Exception as e:
+            raise e
+
+    @abstractmethod
+    async def fault_light_on(self) -> bool:
+        """Turn the fault light of the miner on and return success as a boolean.
+
+        Returns:
+            A boolean value of the success of turning the light on.
+        """
+        pass
+
+    @abstractmethod
+    async def fault_light_off(self) -> bool:
+        """Turn the fault light of the miner off and return success as a boolean.
+
+        Returns:
+            A boolean value of the success of turning the light off.
+        """
+        pass
+
+    @abstractmethod
+    async def check_light(self) -> bool:
+        """Check the status and return on or off as a boolean.
+
+        Returns:
+            A boolean value where `True` represents on and `False` represents off.
+        """
+        pass
+
+    @abstractmethod
+    async def get_config(self) -> MinerConfig:
+        """Get the mining configuration of the miner and return it as a [`MinerConfig`][pyasic.config.MinerConfig].
+
+        Returns:
+            A [`MinerConfig`][pyasic.config.MinerConfig] containing the pool information and mining configuration.
+        """
+        pass
+
+    @abstractmethod
+    async def get_hostname(self) -> str:
+        """Get the hostname of the miner and return it as a string.
+
+        Returns:
+            A string representing the hostname of the miner.
+        """
+        pass
+
+    @abstractmethod
+    async def get_model(self) -> str:
+        """Get the model of the miner and return it as a string.
+
+        Returns:
+            A string representing the model of the miner.
+        """
+        pass
+
+    @abstractmethod
+    async def reboot(self) -> bool:
+        """Reboot the miner and return success as a boolean.
+
+        Returns:
+            A boolean value of the success of rebooting the miner.
+        """
+        pass
+
+    @abstractmethod
+    async def restart_backend(self) -> bool:
+        """Restart the mining process of the miner (bosminer, bmminer, cgminer, etc) and return success as a boolean.
+
+        Returns:
+            A boolean value of the success of restarting the mining process.
+        """
+        pass
+
+    @abstractmethod
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        """Set the mining configuration of the miner.
+
+        Parameters:
+            config: A [`MinerConfig`][pyasic.config.MinerConfig] containing the mining config you want to switch the miner to.
+            user_suffix: A suffix to append to the username when sending to the miner.
+        """
+        return None
+
+    @abstractmethod
+    async def get_mac(self) -> str:
+        """Get the MAC address of the miner and return it as a string.
+
+        Returns:
+            A string representing the MAC address of the miner.
+        """
+        pass
+
+    @abstractmethod
+    async def get_errors(
+        self,
+    ) -> List[Union[WhatsminerError, BraiinsOSError, InnosiliconError, X19Error]]:
+        """Get a list of the errors the miner is experiencing.
+
+        Returns:
+            A list of error classes representing different errors.
+        """
+        pass
+
+    @abstractmethod
+    async def get_data(self) -> MinerData:
+        """Get data from the miner in the form of [`MinerData`][pyasic.data.MinerData].
+
+        Returns:
+            A [`MinerData`][pyasic.data.MinerData] instance containing data from the miner.
+        """
+        return MinerData(ip=str(self.ip))
+
+
+AnyMiner = TypeVar("AnyMiner", bound=BaseMiner)

pyasic/miners/innosilicon/__init__.py

@@ -0,0 +1,15 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from .cgminer import *