bump version number

.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,22 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   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,8 +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)
-![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)
+[![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)
 ## Documentation
 Documentation is located on Read the Docs as [pyasic](https://pyasic.readthedocs.io/en/latest/)
 
@@ -18,13 +18,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
@@ -66,18 +68,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())
 ```
@@ -102,7 +104,7 @@ 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)
-    
+
     # Get data from the miner
     data = await miner.get_data()
     print(data)
@@ -131,11 +133,11 @@ 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)
-    
+
     # List all available commands
     print(miner.api.get_commands())
-    
-    
+
+
 if __name__ == "__main__":
     asyncio.run(get_api_commands("192.168.1.69"))
 ```
@@ -159,13 +161,13 @@ 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)
-    
+
     # 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,25 @@
+# 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

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,13 @@ 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())
 ```

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/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,8 +3,6 @@
 
 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.
@@ -27,6 +25,8 @@ Supported miner types are here on this list.  If your miner (or miner version) i
             * [VE20][pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlusVE20]
         * [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]

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/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

@@ -28,17 +28,21 @@ nav:
       - Miner Network Range: "network/miner_network_range.md"
   - Data:
       - Miner Data: "data/miner_data.md"
+      - Error Codes: "data/error_codes.md"
   - Config:
       - 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

pyasic/API/__init__.py

@@ -55,6 +55,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.
 

pyasic/API/btminer.py

@@ -19,6 +19,7 @@ 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
@@ -187,8 +188,8 @@ class BTMinerAPI(BaseMinerAPI):
 
     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:

pyasic/config/__init__.py

@@ -287,6 +287,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.
 

pyasic/data/__init__.py

@@ -12,10 +12,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from typing import Union
+from typing import Union, List
 from dataclasses import dataclass, field, asdict
 from datetime import datetime
 
+from .error_codes import X19Error, WhatsminerError, BraiinsOSError
+
 
 @dataclass
 class MinerData:
@@ -57,6 +59,7 @@ class MinerData:
         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.
     """
 
     ip: str
@@ -94,7 +97,9 @@ 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]] = field(
+        default_factory=list
+    )
     fault_light: Union[bool, None] = None
 
     def __post_init__(self):

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,4 @@
 
 from .whatsminer import WhatsminerError
 from .bos import BraiinsOSError
+from .X19 import X19Error

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/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)

pyasic/miners/__init__.py

@@ -15,11 +15,13 @@
 import asyncssh
 import logging
 import ipaddress
+from abc import ABC, abstractmethod
 
 from pyasic.data import MinerData
+from pyasic.config import MinerConfig
 
 
-class BaseMiner:
+class BaseMiner(ABC):
     def __init__(self, *args) -> None:
         self.ip = None
         self.uname = "root"
@@ -34,6 +36,11 @@ class BaseMiner:
         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)}"
 
@@ -75,42 +82,56 @@ class BaseMiner:
         except Exception as e:
             raise e
 
+    @abstractmethod
     async def fault_light_on(self) -> bool:
-        return False
+        pass
 
+    @abstractmethod
     async def fault_light_off(self) -> bool:
-        return False
+        pass
 
-    async def send_file(self, src, dest):
-        async with (await self._get_ssh_connection()) as conn:
-            await asyncssh.scp(src, (conn, dest))
+    # 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
+    @abstractmethod
+    async def check_light(self) -> bool:
+        pass
 
+    # @abstractmethod
     async def get_board_info(self):
         return None
 
-    async def get_config(self):
-        return None
+    @abstractmethod
+    async def get_config(self) -> MinerConfig:
+        pass
 
-    async def get_hostname(self):
-        return None
+    @abstractmethod
+    async def get_hostname(self) -> str:
+        pass
 
-    async def get_model(self):
-        return None
+    @abstractmethod
+    async def get_model(self) -> str:
+        pass
 
-    async def reboot(self):
-        return False
+    @abstractmethod
+    async def reboot(self) -> bool:
+        pass
 
-    async def restart_backend(self):
-        return False
+    @abstractmethod
+    async def restart_backend(self) -> bool:
+        pass
 
     async def send_config(self, *args, **kwargs):
         return None
 
-    async def get_mac(self):
-        return None
+    @abstractmethod
+    async def get_mac(self) -> str:
+        pass
+
+    @abstractmethod
+    async def get_errors(self) -> list:
+        pass
 
     async def get_data(self) -> MinerData:
         return MinerData(ip=str(self.ip))

pyasic/miners/_backends/bmminer.py

@@ -154,6 +154,26 @@ class BMMiner(BaseMiner):
             return True
         return False
 
+    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 +188,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 +199,10 @@ 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
@@ -257,7 +282,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

@@ -240,6 +240,49 @@ class BOSMiner(BaseMiner):
             logging.debug(f"{self}: Restarting BOSMiner")
             await conn.run("/etc/init.d/bosminer start")
 
+    async def check_light(self) -> bool:
+        if not self.light:
+            self.light = False
+        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.
 

pyasic/miners/_backends/bosminer_old.py

@@ -15,6 +15,7 @@
 import logging
 
 import ipaddress
+from typing import Union
 
 from pyasic.API.bosminer import BOSMinerAPI
 from pyasic.miners import BaseMiner
@@ -29,7 +30,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 +62,33 @@ 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

pyasic/miners/_backends/btminer.py

@@ -23,6 +23,7 @@ from pyasic.API 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,40 @@ class BTMiner(BaseMiner):
 
         return str(mac).upper()
 
+    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 reboot(self) -> bool:
+        return False
+
+    async def restart_backend(self) -> bool:
+        return False
+
+    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.
 

pyasic/miners/_backends/cgminer.py

@@ -151,6 +151,23 @@ 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 get_mac(self) -> str:
+        return "00:00:00:00:00:00"
+
     async def get_data(self) -> MinerData:
         """Get data from the miner.
 

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

@@ -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/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 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

@@ -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/__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/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 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/__init__.py

@@ -19,4 +19,5 @@ from .M30S_Plus_Plus import M30SPlusPlus, M30SPlusPlusVG30, M30SPlusPlusVG40
 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,6 +14,8 @@
 
 from pyasic.miners._backends import BMMiner  # noqa - Ignore access to _module
 
+from pyasic.settings import PyasicSettings
+
 import httpx
 from typing import Union
 
@@ -22,11 +24,13 @@ 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) -> 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:
@@ -36,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:
@@ -51,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)
@@ -62,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,33 +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) -> bool:
+    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("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:
             data = data.json()
             light = data["blink"]
+            self.light = light
             return light
-        return False
+        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:
@@ -51,7 +57,7 @@ class BMMinerX19(BMMiner):
 
     async def send_config(self, yaml_config, ip_user: bool = False) -> None:
         url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(self.uname, self.pwd)
         if ip_user:
             suffix = str(self.ip).split(".")[-1]
             conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
@@ -69,10 +75,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:
@@ -82,10 +88,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:
@@ -97,7 +103,7 @@ 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)
@@ -110,7 +116,7 @@ class BMMinerX19(BMMiner):
 
     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)
@@ -123,9 +129,24 @@ class BMMinerX19(BMMiner):
 
     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/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/A8X/A821.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from A8X import CGMinerA8X  # 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
 
 

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

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from A8X import CGMinerA8X  # 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
 
 

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

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from A8X import CGMinerA8X  # 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
 
 

pyasic/miners/miner_factory.py

@@ -45,93 +45,103 @@ import asyncssh
 AnyMiner = TypeVar("AnyMiner", bound=BaseMiner)
 
 MINER_CLASSES = {
-    "Antminer S9": {
+    "ANTMINER S9": {
         "Default": BOSMinerS9,
         "BOSMiner": BOSMinerOld,
         "BOSMiner+": BOSMinerS9,
         "BMMiner": BMMinerS9,
         "CGMiner": CGMinerS9,
     },
-    "Antminer S9i": {
+    "ANTMINER S9I": {
         "Default": BMMinerS9i,
         "BMMiner": BMMinerS9i,
     },
-    "Antminer S17": {
+    "ANTMINER T9": {
+        "Default": BMMinerT9,
+        "BMMiner": BMMinerT9,
+        "Hiveon": HiveonT9,
+    },
+    "ANTMINER S17": {
         "Default": BMMinerS17,
         "BOSMiner+": BOSMinerS17,
         "BMMiner": BMMinerS17,
         "CGMiner": CGMinerS17,
     },
-    "Antminer S17+": {
+    "ANTMINER S17+": {
         "Default": BMMinerS17Plus,
         "BOSMiner+": BOSMinerS17Plus,
         "BMMiner": BMMinerS17Plus,
         "CGMiner": CGMinerS17Plus,
     },
-    "Antminer S17 Pro": {
+    "ANTMINER S17 PRO": {
         "Default": BMMinerS17Pro,
         "BOSMiner+": BOSMinerS17Pro,
         "BMMiner": BMMinerS17Pro,
         "CGMiner": CGMinerS17Pro,
     },
-    "Antminer S17e": {
+    "ANTMINER S17E": {
         "Default": BMMinerS17e,
         "BOSMiner+": BOSMinerS17e,
         "BMMiner": BMMinerS17e,
         "CGMiner": CGMinerS17e,
     },
-    "Antminer T17": {
+    "ANTMINER T17": {
         "Default": BMMinerT17,
         "BOSMiner+": BOSMinerT17,
         "BMMiner": BMMinerT17,
         "CGMiner": CGMinerT17,
     },
-    "Antminer T17+": {
+    "ANTMINER T17+": {
         "Default": BMMinerT17Plus,
         "BOSMiner+": BOSMinerT17Plus,
         "BMMiner": BMMinerT17Plus,
         "CGMiner": CGMinerT17Plus,
     },
-    "Antminer T17e": {
+    "ANTMINER T17E": {
         "Default": BMMinerT17e,
         "BOSMiner+": BOSMinerT17e,
         "BMMiner": BMMinerT17e,
         "CGMiner": CGMinerT17e,
     },
-    "Antminer S19": {
+    "ANTMINER S19": {
         "Default": BMMinerS19,
         "BOSMiner+": BOSMinerS19,
         "BMMiner": BMMinerS19,
         "CGMiner": CGMinerS19,
     },
-    "Antminer S19 Pro": {
+    "ANTMINER S19 PRO": {
         "Default": BMMinerS19Pro,
         "BOSMiner+": BOSMinerS19Pro,
         "BMMiner": BMMinerS19Pro,
         "CGMiner": CGMinerS19Pro,
     },
-    "Antminer S19j": {
+    "ANTMINER S19J": {
         "Default": BMMinerS19j,
         "BOSMiner+": BOSMinerS19j,
         "BMMiner": BMMinerS19j,
         "CGMiner": CGMinerS19j,
     },
-    "Antminer S19j Pro": {
+    "ANTMINER S19J PRO": {
         "Default": BMMinerS19jPro,
         "BOSMiner+": BOSMinerS19jPro,
         "BMMiner": BMMinerS19jPro,
         "CGMiner": CGMinerS19jPro,
     },
-    "Antminer S19a": {
+    "ANTMINER S19A": {
         "Default": BMMinerS19a,
         "BMMiner": BMMinerS19a,
     },
-    "Antminer T19": {
+    "ANTMINER T19": {
         "Default": BMMinerT19,
         "BOSMiner+": BOSMinerT19,
         "BMMiner": BMMinerT19,
         "CGMiner": CGMinerT19,
     },
+    "M20": {
+        "Default": BTMinerM20,
+        "BTMiner": BTMinerM20,
+        "10": BTMinerM20V10,
+    },
     "M20S": {
         "Default": BTMinerM20S,
         "BTMiner": BTMinerM20S,
@@ -190,6 +200,11 @@ MINER_CLASSES = {
         "Default": BTMinerM32S,
         "BTMiner": BTMinerM32S,
     },
+    "M32": {
+        "Default": BTMinerM32,
+        "BTMiner": BTMinerM32,
+        "20": BTMinerM32V20,
+    },
     "AvalonMiner 721": {
         "Default": CGMinerAvalon721,
         "CGMiner": CGMinerAvalon721,
@@ -230,6 +245,7 @@ MINER_CLASSES = {
         "Default": CGMinerAvalon1066,
         "CGMiner": CGMinerAvalon1066,
     },
+    "Unknown": {"Default": UnknownMiner},
 }
 
 
@@ -426,9 +442,9 @@ class MinerFactory(metaclass=Singleton):
 
                 if board_name:
                     if board_name == "am1-s9":
-                        model = "Antminer S9"
+                        model = "ANTMINER S9"
                     if board_name == "am2-s17":
-                        model = "Antminer S17"
+                        model = "ANTMINER S17"
                     api = "BOSMiner+"
                     return model, api, None
 
@@ -441,7 +457,7 @@ class MinerFactory(metaclass=Singleton):
                     if data.status_code == 200:
                         data = data.json()
                     if "minertype" in data.keys():
-                        model = data["minertype"]
+                        model = data["minertype"].upper()
                     if "bmminer" in "\t".join(data.keys()):
                         api = "BMMiner"
                 except Exception as e:
@@ -454,15 +470,15 @@ class MinerFactory(metaclass=Singleton):
                 # check for model, for most miners
                 if not devdetails["DEVDETAILS"][0]["Model"] == "":
                     # model of most miners
-                    model = devdetails["DEVDETAILS"][0]["Model"]
+                    model = devdetails["DEVDETAILS"][0]["Model"].upper()
 
                 # if model fails, try driver
                 else:
                     # some avalonminers have model in driver
-                    model = devdetails["DEVDETAILS"][0]["Driver"]
+                    model = devdetails["DEVDETAILS"][0]["Driver"].upper()
             else:
                 if "s9" in devdetails["STATUS"][0]["Description"]:
-                    model = "Antminer S9"
+                    model = "ANTMINER S9"
 
         # if we have version we can get API type from here
         if version:
@@ -497,7 +513,7 @@ class MinerFactory(metaclass=Singleton):
                 # check for avalonminers
                 if version["VERSION"][0].get("PROD"):
                     _data = version["VERSION"][0]["PROD"].split("-")
-                    model = _data[0]
+                    model = _data[0].upper()
                     if len(data) > 1:
                         ver = _data[1]
                 elif version["VERSION"][0].get("MODEL"):
@@ -522,22 +538,38 @@ class MinerFactory(metaclass=Singleton):
             ):
                 # try to get "Type" which is model
                 if version["VERSION"][0].get("Type"):
-                    model = version["VERSION"][0]["Type"]
+                    model = version["VERSION"][0]["Type"].upper()
 
                 # braiins OS bug check just in case
                 elif "am2-s17" in version["STATUS"][0]["Description"]:
-                    model = "Antminer S17"
+                    model = "ANTMINER S17"
+
+        if not model:
+            stats = await self._send_api_command(str(ip), "stats")
+            if stats:
+                if "STATS" in stats.keys():
+                    if stats["STATS"][0].get("Type"):
+                        _model = stats["STATS"][0]["Type"].upper()
+                        if " BB" in _model:
+                            _model = _model.split(" BB")[0]
+                        if " XILINX" in _model:
+                            _model = _model.split(" XILINX")[0]
+                        if "PRO" in _model and not " PRO" in _model:
+                            model = _model.replace("PRO", " PRO")
 
         if model:
+            if " HIVEON" in model:
+                model = model.split(" HIVEON")[0]
+                api = "Hiveon"
             # whatsminer have a V in their version string (M20SV41), remove everything after it
             if "V" in model:
                 _ver = model.split("V")
                 if len(_ver) > 1:
                     ver = model.split("V")[1]
                     model = model.split("V")[0]
-            # don't need "Bitmain", just "Antminer XX" as model
-            if "Bitmain " in model:
-                model = model.replace("Bitmain ", "")
+            # don't need "Bitmain", just "ANTMINER XX" as model
+            if "BITMAIN " in model:
+                model = model.replace("BITMAIN ", "")
         return model, api, ver
 
     @staticmethod

pyasic/miners/unknown.py

@@ -31,3 +31,29 @@ class UnknownMiner(BaseMiner):
 
     async def get_hostname(self):
         return "Unknown"
+
+    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_config(self) -> None:
+        return None
+
+    async def get_errors(self) -> list:
+        return []
+
+    async def get_mac(self) -> str:
+        return "00:00:00:00:00:00"
+
+    async def reboot(self) -> bool:
+        return False
+
+    async def restart_backend(self) -> bool:
+        return False

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

@@ -0,0 +1,31 @@
+#  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 BTMiner  # noqa - Ignore access to _module
+from pyasic.miners._types import (  # noqa - Ignore access to _module
+    M20,
+    M20V10,
+)
+
+
+class BTMinerM20(BTMiner, M20):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+
+class BTMinerM20V10(BTMiner, M20V10):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

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

@@ -12,6 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from .M20 import BTMinerM20, BTMinerM20V10
 from .M20S import BTMinerM20S, BTMinerM20SV10, BTMinerM20SV20
 from .M20S_Plus import BTMinerM20SPlus
 

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

@@ -0,0 +1,28 @@
+#  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 BTMiner  # noqa - Ignore access to _module
+from pyasic.miners._types import M32, M32V20  # noqa - Ignore access to _module
+
+
+class BTMinerM32(BTMiner, M32):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+
+class BTMinerM32V20(BTMiner, M32V20):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

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

@@ -13,7 +13,9 @@
 #  limitations under the License.
 
 from pyasic.miners._backends import BTMiner  # noqa - Ignore access to _module
-from pyasic.miners._types import M32S  # noqa - Ignore access to _module
+from pyasic.miners._types import (
+    M32S,
+)  # noqa - Ignore access to _module
 
 
 class BTMinerM32S(BTMiner, M32S):

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

@@ -34,4 +34,5 @@ from .M30S_Plus_Plus import (
 from .M31S import BTMinerM31S
 from .M31S_Plus import BTMinerM31SPlus, BTMinerM31SPlusVE20
 
+from .M32 import BTMinerM32, BTMinerM32V20
 from .M32S import BTMinerM32S

pyasic/network/__init__.py

@@ -208,8 +208,8 @@ async def ping_miner(
     ip: ipaddress.ip_address, port=4028
 ) -> Union[None, ipaddress.ip_address]:
     for i in range(PyasicSettings().network_ping_retries):
-        connection_fut = asyncio.open_connection(str(ip), port)
         try:
+            connection_fut = asyncio.open_connection(str(ip), port)
             # get the read and write streams from the connection
             reader, writer = await asyncio.wait_for(
                 connection_fut, timeout=PyasicSettings().network_ping_timeout
@@ -253,10 +253,10 @@ async def ping_and_get_miner(
         except asyncio.exceptions.TimeoutError:
             # ping failed if we time out
             continue
-        except ConnectionRefusedError:
+        except ConnectionRefusedError as e:
             # handle for other connection errors
             logging.debug(f"{str(ip)}: Connection Refused.")
-            raise ConnectionRefusedError
+            raise e
         # ping failed, likely with an exception
         except Exception as e:
             logging.warning(f"{str(ip)}: {e}")

pyasic/settings/__init__.py

@@ -35,6 +35,8 @@ class PyasicSettings(metaclass=Singleton):
     miner_get_data_retries: int = 1
 
     global_whatsminer_password = "admin"
+    global_x19_password = "root"
+    global_x17_password = "root"
 
     debug: bool = False
     logfile: bool = False

pyasic/tests/__init__.py

@@ -13,6 +13,8 @@
 #  limitations under the License.
 
 import unittest
+from pyasic.tests.miners_tests import MinersTest
+from pyasic.tests.network_tests import NetworkTest
 
 if __name__ == "__main__":
     unittest.main()

pyasic/tests/miners_tests/__init__.py

@@ -0,0 +1,54 @@
+#  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 unittest
+
+from pyasic.miners.miner_factory import MINER_CLASSES
+
+import inspect
+import sys
+
+
+class MinersTest(unittest.TestCase):
+    def test_miner_model_creation(self):
+        for miner_model in MINER_CLASSES.keys():
+            for miner_api in MINER_CLASSES[miner_model].keys():
+                with self.subTest(miner_model=miner_model, miner_api=miner_api):
+                    miner = MINER_CLASSES[miner_model][miner_api]("0.0.0.0")
+                    self.assertTrue(
+                        isinstance(miner, MINER_CLASSES[miner_model][miner_api])
+                    )
+
+    def test_miner_backend_backup_creation(self):
+        backends = inspect.getmembers(
+            sys.modules["pyasic.miners._backends"], inspect.isclass
+        )
+        for backend in backends:
+            miner_class = backend[1]
+            with self.subTest(miner_class=miner_class):
+                miner = miner_class("0.0.0.0")
+                self.assertTrue(isinstance(miner, miner_class))
+
+    def test_miner_type_creation_failure(self):
+        backends = inspect.getmembers(
+            sys.modules["pyasic.miners._types"], inspect.isclass
+        )
+        for backend in backends:
+            miner_class = backend[1]
+            with self.subTest(miner_class=miner_class):
+                with self.assertRaises(TypeError):
+                    miner_class("0.0.0.0")
+
+
+if __name__ == "__main__":
+    unittest.main()

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.13.0"
+version = "0.15.1"
 description = "A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH."
 authors = ["UpstreamData <brett@upstreamdata.ca>"]
 repository = "https://github.com/UpstreamData/pyasic"

requirements-dev.txt

@@ -0,0 +1,2 @@
+-r requirements.txt
+pre-commit