made slight optimizations to get_data and the way the miner gets mac data

This reverts commit e7b01ccdab.

API/__init__.py

@@ -59,7 +59,9 @@ class BaseMinerAPI:
             ]
         ]
 
-    async def multicommand(self, *commands: str) -> dict:
+    async def multicommand(
+        self, *commands: str, ignore_x19_error: bool = False
+    ) -> dict:
         """Creates and sends multiple commands as one command to the miner."""
         logging.debug(f"{self.ip}: Sending multicommand: {[*commands]}")
         # split the commands into a proper list
@@ -78,8 +80,8 @@ If you are sure you want to use this command please use API.send_command("{item}
         command = "+".join(commands)
         data = None
         try:
-            data = await self.send_command(command)
-        except APIError as e:
+            data = await self.send_command(command, x19_command=ignore_x19_error)
+        except APIError:
             try:
                 data = {}
                 # S19 handler, try again
@@ -96,9 +98,10 @@ If you are sure you want to use this command please use API.send_command("{item}
 
     async def send_command(
         self,
-        command: str,
+        command: str or bytes,
         parameters: str or int or bool = None,
         ignore_errors: bool = False,
+        x19_command: bool = False,
     ) -> dict:
         """Send an API command to the miner and return the result."""
         try:
@@ -143,7 +146,8 @@ If you are sure you want to use this command please use API.send_command("{item}
             # validate the command succeeded
             validation = self.validate_command_output(data)
             if not validation[0]:
-                logging.warning(f"{self.ip}: API Command Error: {validation[1]}")
+                if not x19_command:
+                    logging.warning(f"{self.ip}: API Command Error: {validation[1]}")
                 raise APIError(validation[1])
 
         return data
@@ -193,6 +197,8 @@ If you are sure you want to use this command please use API.send_command("{item}
             str_data = str_data.replace("}{", "},{")
             # fix an error with a bmminer return  having a specific comma that breaks json.loads()
             str_data = str_data.replace("[,{", "[{")
+            # fix an error with a btminer return  having a specific comma that breaks json.loads()
+            str_data = str_data.replace("inf", "0")
             # parse the json
             parsed_data = json.loads(str_data)
         # handle bad json

API/btminer.py

@@ -163,6 +163,7 @@ class BTMinerAPI(BaseMinerAPI):
         command: str or bytes,
         parameters: str or int or bool = None,
         ignore_errors: bool = False,
+        **kwargs,
     ) -> dict:
         """Send a command to the miner API.
 
@@ -434,7 +435,7 @@ class BTMinerAPI(BaseMinerAPI):
         enc_command = create_privileged_cmd(token_data, command)
         return await self.send_command(enc_command)
 
-    async def update_firmware(self):
+    async def update_firmware(self):  # noqa - static
         # to be determined if this will be added later
         # requires a file stream in bytes
         return NotImplementedError

README.md

@@ -18,7 +18,7 @@ if __name__ == '__main__':
     main()
 ```
 2. Make a build of the CFG Util for your system using cx_freeze and ```make_cfg_tool_exe.py```
-(Alternatively, you can get a build made by me here -> https://drive.google.com/drive/folders/1nzojuGRu0IszIGpwx7SvG5RlJ2_KXIOv)
+(Alternatively, you can get a build made by me here -> https://drive.google.com/drive/folders/147vBXbuaX85inataXeSAiKk8IKf-7xtR)
    1. Open either Command Prompt on Windows or Terminal on Mac or UNIX.
    2. Navigate to this directory, and run ```make_cfg_tool_exe.py build``` on Windows or ```python3 make_cfg_tool_exe.py``` on Mac or UNIX.
 
@@ -102,57 +102,6 @@ async def get_miner_hashrate(ip: str):
     print(data)
 
 
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_hashrate(str("192.168.1.69")))
-```
-
-<br>
-Or generate a miner directly without the factory:
-
-```python
-import asyncio
-from miners.bosminer import BOSMiner
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_hashrate(ip: str):
-    # Create a BOSminer miner object
-    miner = BOSMiner(ip)
-    # Get the API data
-    summary = await miner.api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, 'MHS 5s')
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_hashrate(str("192.168.1.69")))
-```
-
-<br>
-Or finally, just get the API directly:
-
-```python
-import asyncio
-from API.bosminer import BOSMinerAPI
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_hashrate(ip: str):
-    # Create a BOSminerAPI object
-    # Port can be declared manually, if not it defaults to 4028
-    api = BOSMinerAPI(ip, port=4028)
-    # Get the API data
-    summary = await api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, 'MHS 5s')
-    print(data)
-
-
 if __name__ == '__main__':
     asyncio.new_event_loop().run_until_complete(
         get_miner_hashrate(str("192.168.1.69")))
@@ -162,13 +111,40 @@ if __name__ == '__main__':
 Now that you know that, lets move on to some common API functions that you might want to use.
 
 ### Common commands:
+* Get the data used by the config utility, this includes pool data, wattage use, temperature, hashrate, etc:
+
+```python
+import asyncio
+import ipaddress
+from miners.miner_factory import MinerFactory
+
+
+async def get_miner_pool_data(ip: str):
+    # Instantiate a Miner Factory to generate miners from their IP
+    miner_factory = MinerFactory()
+    # Make the string IP into an IP address
+    miner_ip = ipaddress.ip_address(ip)
+    # Wait for the factory to return the miner
+    miner = await miner_factory.get_miner(miner_ip)
+    # Get the data
+    data = await miner.get_data()
+    
+    print(data)
+
+
+if __name__ == '__main__':
+    asyncio.new_event_loop().run_until_complete(
+        get_miner_pool_data(str("192.168.1.69")))
+```
+
+
+
 * Getting pool data:
 
 ```python
 import asyncio
 import ipaddress
 from miners.miner_factory import MinerFactory
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_pool_data(ip: str):
@@ -182,7 +158,7 @@ async def get_miner_pool_data(ip: str):
     pools = await miner.api.pools()
     # safe_parse_api_data parses the data from a miner API
     # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(pools, 'POOLS')
+    data = pools["POOLS"]
     # parse further from here to get all the pool info you want.
     # each pool is on a different index eg:
     # data[0] is pool 1
@@ -208,7 +184,6 @@ A pretty good example of really trying to make this robust is in ```cfg_util.fun
 import asyncio
 import ipaddress
 from miners.miner_factory import MinerFactory
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_temperature_data(ip: str):
@@ -220,9 +195,8 @@ async def get_miner_temperature_data(ip: str):
     miner = await miner_factory.get_miner(miner_ip)
     # Get the API data
     summary = await miner.api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, "Temperature")
+
+    data = summary['SUMMARY'][0]["Temperature"]
     print(data)
 
 
@@ -239,10 +213,10 @@ How about data on the power usage of the miner?  This one only works for Whatsmi
 import asyncio
 import ipaddress
 from miners.miner_factory import MinerFactory
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_power_data(ip: str):
+    data = None
     # Instantiate a Miner Factory to generate miners from their IP
     miner_factory = MinerFactory()
     # Make the string IP into an IP address
@@ -254,16 +228,16 @@ async def get_miner_power_data(ip: str):
         # send the command
         tunerstatus = await miner.api.tunerstatus()
         # parse the return
-        data = await safe_parse_api_data(tunerstatus, 'TUNERSTATUS', 0,
-                                         "PowerLimit")
+        data = tunerstatus['TUNERSTATUS'][0]["PowerLimit"]
     else:
         # send the command
         # whatsminers have the power info in summary
         summary = await miner.api.summary()
         # parse the return
-        data = await safe_parse_api_data(summary, 'SUMMARY', 0, "Power")
+        data = summary['SUMMARY'][0]["Power"]
 
-    print(data)
+    if data:
+       print(data)
 
 
 if __name__ == '__main__':
@@ -293,12 +267,10 @@ async def get_miner_hashrate_and_pool(ip: str):
     # Get the API data
     api_data = await miner.api.multicommand("pools", "summary")
     if "pools" in api_data.keys():
-        user = await safe_parse_api_data(api_data, "pools", 0, "POOLS", 0,
-                                         "User")
+        user = api_data["pools"][0]["POOLS"][0]["User"]
         print(user)
     if "summary" in api_data.keys():
-        hashrate = await safe_parse_api_data(api_data, "summary", 0, "SUMMARY",
-                                             0, "MHS av")
+        hashrate = api_data["summary"][0]["SUMMARY"][0]["MHS av"]
         print(hashrate)
 
 

board_util.py

@@ -1,4 +0,0 @@
-from tools.bad_board_util import main
-
-if __name__ == "__main__":
-    main()

config/__init__.py

@@ -76,3 +76,13 @@ SAMPLE CONFIG
     }
 }
 """
+
+
+def general_config_convert_pools(config: dict):
+    out_config = {}
+    pools = config.get("pool_groups")
+    if pools:
+        if len(pools) > 0:
+            pools = pools[0]
+            out_config = pools["pools"][:3]
+    return out_config

config/bos.py

@@ -1,6 +1,6 @@
 import time
+
 import yaml
-import toml
 
 
 def bos_config_convert(config: dict):

data/__init__.py

@@ -0,0 +1,115 @@
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+
+
+@dataclass
+class MinerData:
+    """A Dataclass to standardize data returned from miners (specifically AnyMiner().get_data())
+
+    :param ip: The IP of the miner as a str.
+    :param datetime: The time and date this data was generated.
+    :param model: The model of the miner as a str.
+    :param hostname: The network hostname of the miner as a str.
+    :param hashrate: The hashrate of the miner in TH/s as a int.
+    :param left_board_temp: The temp of the left PCB as an int.
+    :param left_board_chip_temp: The temp of the left board chips as an int.
+    :param center_board_temp: The temp of the center PCB as an int.
+    :param center_board_chip_temp: The temp of the center board chips as an int.
+    :param right_board_temp: The temp of the right PCB as an int.
+    :param right_board_chip_temp: The temp of the right board chips as an int.
+    :param wattage: Wattage of the miner as an int.
+    :param fan_1: The speed of the first fan as an int.
+    :param fan_2: The speed of the second fan as an int.
+    :param fan_3: The speed of the third fan as an int.
+    :param fan_4: The speed of the fourth fan as an int.
+    :param left_chips: The number of chips online in the left board as an int.
+    :param center_chips: The number of chips online in the left board as an int.
+    :param right_chips: The number of chips online in the left board as an int.
+    :param ideal_chips: The ideal number of chips in the miner as an int.
+    :param pool_split: The pool split as a str.
+    :param pool_1_url: The first pool url on the miner as a str.
+    :param pool_1_user: The first pool user on the miner as a str.
+    :param pool_2_url: The second pool url on the miner as a str.
+    :param pool_2_user: The second pool user on the miner as a str.
+    """
+
+    ip: str
+    datetime: datetime = None
+    mac: str = "00:00:00:00:00:00"
+    model: str = "Unknown"
+    hostname: str = "Unknown"
+    hashrate: float = 0
+    temperature_avg: int = field(init=False)
+    left_board_temp: int = 0
+    left_board_chip_temp: int = 0
+    center_board_temp: int = 0
+    center_board_chip_temp: int = 0
+    right_board_temp: int = 0
+    right_board_chip_temp: int = 0
+    wattage: int = 0
+    fan_1: int = -1
+    fan_2: int = -1
+    fan_3: int = -1
+    fan_4: int = -1
+    left_chips: int = 0
+    center_chips: int = 0
+    right_chips: int = 0
+    total_chips: int = field(init=False)
+    ideal_chips: int = 1
+    percent_ideal: float = field(init=False)
+    nominal: int = field(init=False)
+    pool_split: str = "0"
+    pool_1_url: str = "Unknown"
+    pool_1_user: str = "Unknown"
+    pool_2_url: str = ""
+    pool_2_user: str = ""
+
+    def __post_init__(self):
+        self.datetime = datetime.now()
+
+    @property
+    def total_chips(self):  # noqa - Skip PyCharm inspection
+        return self.right_chips + self.center_chips + self.left_chips
+
+    @total_chips.setter
+    def total_chips(self, val):
+        pass
+
+    @property
+    def nominal(self):  # noqa - Skip PyCharm inspection
+        return self.ideal_chips == self.total_chips
+
+    @nominal.setter
+    def nominal(self, val):
+        pass
+
+    @property
+    def percent_ideal(self):  # noqa - Skip PyCharm inspection
+        return round((self.total_chips / self.ideal_chips) * 100)
+
+    @percent_ideal.setter
+    def percent_ideal(self, val):
+        pass
+
+    @property
+    def temperature_avg(self):  # noqa - Skip PyCharm inspection
+        total_temp = 0
+        temp_count = 0
+        for temp in [
+            self.left_board_chip_temp,
+            self.center_board_chip_temp,
+            self.right_board_chip_temp,
+        ]:
+            if not temp == 0:
+                total_temp += temp
+                temp_count += 1
+        if not temp_count > 0:
+            return 0
+        return round(total_temp / temp_count)
+
+    @temperature_avg.setter
+    def temperature_avg(self, val):
+        pass
+
+    def asdict(self):
+        return asdict(self)

logger/__init__.py

@@ -2,17 +2,23 @@ import logging
 from settings import DEBUG
 
 
-logging.basicConfig(
-    # filename="logfile.txt",
-    # filemode="a",
-    format="[%(levelname)s][%(asctime)s](%(name)s) - %(message)s",
-    datefmt="%x %X",
-)
-logger = logging.getLogger()
+def init_logger():
+    logging.basicConfig(
+        # filename="logfile.txt",
+        # filemode="a",
+        format="%(pathname)s:%(lineno)d in %(funcName)s\n[%(levelname)s][%(asctime)s](%(name)s) - %(message)s",
+        datefmt="%x %X",
+    )
+    _logger = logging.getLogger()
 
-if DEBUG:
-    logger.setLevel(logging.DEBUG)
-    logging.getLogger("asyncssh").setLevel(logging.DEBUG)
-else:
-    logger.setLevel(logging.INFO)
-    logging.getLogger("asyncssh").setLevel(logging.WARNING)
+    if DEBUG:
+        _logger.setLevel(logging.DEBUG)
+        logging.getLogger("asyncssh").setLevel(logging.DEBUG)
+    else:
+        _logger.setLevel(logging.WARNING)
+        logging.getLogger("asyncssh").setLevel(logging.WARNING)
+
+    return _logger
+
+
+logger = init_logger()

make_board_tool_exe.py

@@ -1,44 +0,0 @@
-"""
-Make a build of the board tool.
-
-Usage: make_board_tool_exe.py build
-
-The build will show up in the build directory.
-"""
-import datetime
-import sys
-import os
-from cx_Freeze import setup, Executable
-
-base = None
-if sys.platform == "win32":
-    base = "Win32GUI"
-
-version = datetime.datetime.now()
-version = version.strftime("%y.%m.%d")
-print(version)
-
-
-setup(
-    name="UpstreamBoardUtil.exe",
-    version=version,
-    description="Upstream Data Board Utility Build",
-    options={
-        "build_exe": {
-            "build_exe": f"{os.getcwd()}\\build\\board_util\\UpstreamBoardUtil-{version}-{sys.platform}\\",
-            "include_files": [
-                os.path.join(os.getcwd(), "settings/settings.toml"),
-            ],
-            "include_msvcr": True,
-            "add_to_path": True,
-        },
-    },
-    executables=[
-        Executable(
-            "board_util.py",
-            base=base,
-            icon="icon.ico",
-            target_name="UpstreamBoardUtil.exe",
-        )
-    ],
-)

make_cfg_tool_exe.py

@@ -30,6 +30,9 @@ setup(
                 os.path.join(os.getcwd(), "settings/settings.toml"),
                 os.path.join(os.getcwd(), "static/CFG-Util-README.md"),
             ],
+            "excludes": [
+                os.path.join(os.getcwd(), "tools/web_testbench/files"),
+            ],
         },
     },
     executables=[

miners/__init__.py

@@ -1,28 +1,35 @@
-from API.bmminer import BMMinerAPI
-from API.bosminer import BOSMinerAPI
-from API.cgminer import CGMinerAPI
-from API.btminer import BTMinerAPI
-from API.unknown import UnknownAPI
-import ipaddress
 import asyncssh
 import logging
+import ipaddress
+
+from data import MinerData
 
 
 class BaseMiner:
-    def __init__(
-        self,
-        ip: str,
-        api: BMMinerAPI or BOSMinerAPI or CGMinerAPI or BTMinerAPI or UnknownAPI,
-    ) -> None:
-        self.ip = ipaddress.ip_address(ip)
-        self.uname = None
-        self.pwd = None
-        self.api = api
+    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
+
+    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"""
@@ -40,7 +47,7 @@ class BaseMiner:
                 conn = await asyncssh.connect(
                     str(self.ip),
                     known_hosts=None,
-                    username="admin",
+                    username="root",
                     password="admin",
                     server_host_key_algs=["ssh-rsa"],
                 )
@@ -48,9 +55,9 @@ class BaseMiner:
             except Exception as e:
                 # logging.warning(f"{self} raised an exception: {e}")
                 raise e
-        except OSError:
+        except OSError as e:
             logging.warning(f"Connection refused: {self}")
-            return None
+            raise e
         except Exception as e:
             # logging.warning(f"{self} raised an exception: {e}")
             raise e
@@ -89,19 +96,8 @@ class BaseMiner:
     async def send_config(self, *args, **kwargs):
         return None
 
+    async def get_mac(self):
+        return None
+
     async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": "0",
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
-        return data
+        return MinerData(ip=str(self.ip))

miners/_backends/__init__.py

@@ -0,0 +1,5 @@
+from .bmminer import BMMiner
+from .bosminer import BOSMiner
+from .btminer import BTMiner
+from .cgminer import CGMiner
+from .hiveon import Hiveon

miners/_backends/bmminer.py

@@ -1,21 +1,24 @@
+import ipaddress
+import logging
+
+
 from API.bmminer import BMMinerAPI
 from miners import BaseMiner
-import logging
+
+from data import MinerData
+
 from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
 
 
 class BMMiner(BaseMiner):
     def __init__(self, ip: str) -> None:
-        api = BMMinerAPI(ip)
-        super().__init__(ip, api)
-        self.model = None
-        self.config = None
+        super().__init__(ip)
+        self.ip = ipaddress.ip_address(ip)
+        self.api = BMMinerAPI(ip)
+        self.api_type = "BMMiner"
         self.uname = "root"
         self.pwd = "admin"
 
-    def __repr__(self) -> str:
-        return f"BMMiner: {str(self.ip)}"
-
     async def get_model(self) -> str or None:
         """Get miner model.
 
@@ -64,7 +67,7 @@ class BMMiner(BaseMiner):
                     # return ? if we fail to get hostname with no ssh connection
                     logging.warning(f"Failed to get hostname for miner: {self}")
                     return "?"
-        except Exception as e:
+        except Exception:
             # return ? if we fail to get hostname with an exception
             logging.warning(f"Failed to get hostname for miner: {self}")
             return "?"
@@ -124,34 +127,30 @@ class BMMiner(BaseMiner):
             return True
         return False
 
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": 0,
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
+    async def get_data(self) -> MinerData:
+        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()
 
         if model:
-            data["Model"] = model
+            data.model = model
 
         if hostname:
-            data["Hostname"] = hostname
+            data.hostname = hostname
+
+        if mac:
+            data.mac = mac
 
         miner_data = None
         for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand("summary", "pools", "stats")
+            miner_data = await self.api.multicommand(
+                "summary", "pools", "stats", ignore_x19_error=True
+            )
             if miner_data:
                 break
 
@@ -166,18 +165,49 @@ class BMMiner(BaseMiner):
             hr = summary.get("SUMMARY")
             if hr:
                 if len(hr) > 0:
-                    hr = hr[0].get("GHS 5s")
+                    hr = hr[0].get("GHS av")
                     if hr:
-                        data["Hashrate"] = round(hr / 1000, 2)
+                        data.hashrate = round(hr / 1000, 2)
+
+        if stats:
+            boards = stats.get("STATS")
+            if boards:
+                if len(boards) > 0:
+                    for board_num in range(1, 16, 5):
+                        for _b_num in range(5):
+                            b = boards[1].get(f"chain_acn{board_num + _b_num}")
+
+                            if b and not b == 0 and board_offset == -1:
+                                board_offset = board_num
+                    if board_offset == -1:
+                        board_offset = 1
+
+                    data.left_chips = boards[1].get(f"chain_acn{board_offset}")
+                    data.center_chips = boards[1].get(f"chain_acn{board_offset+1}")
+                    data.right_chips = boards[1].get(f"chain_acn{board_offset+2}")
 
         if stats:
             temp = stats.get("STATS")
             if temp:
                 if len(temp) > 1:
-                    for item in ["temp2", "temp1", "temp3"]:
-                        temperature = temp[1].get(item)
-                        if temperature and not temperature == 0.0:
-                            data["Temperature"] = round(temperature)
+                    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}")
+                        )
+
+                    board_map = {0: "left_board", 1: "center_board", 2: "right_board"}
+                    for item in range(3):
+                        board_temp = temp[1].get(f"temp{item + board_offset}")
+                        chip_temp = temp[1].get(f"temp2_{item + board_offset}")
+                        setattr(data, f"{board_map[item]}_chip_temp", chip_temp)
+                        setattr(data, f"{board_map[item]}_temp", board_temp)
 
         if pools:
             pool_1 = None
@@ -205,27 +235,24 @@ class BMMiner(BaseMiner):
                 quota = f"{pool_1_quota}/{pool_2_quota}"
 
             if pool_1:
-                if pool_1.startswith("stratum+tcp://"):
-                    pool_1.replace("stratum+tcp://", "")
-                if pool_1.startswith("stratum2+tcp://"):
-                    pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = 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
-                data["Pool User"] = pool_1_user
+                data.pool_1_user = pool_1_user
 
             if pool_2:
-                if pool_2.startswith("stratum+tcp://"):
-                    pool_2.replace("stratum+tcp://", "")
-                if pool_2.startswith("stratum2+tcp://"):
-                    pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = 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
+                data.pool_2_user = pool_2_user
 
             if quota:
-                data["Split"] = str(quota)
+                data.pool_split = str(quota)
 
         return data

miners/_backends/bosminer.py

@@ -1,24 +1,30 @@
+import ipaddress
+import logging
+import json
+
+import toml
+
+
 from miners import BaseMiner
 from API.bosminer import BOSMinerAPI
-import toml
+from API import APIError
+
+from data import MinerData
+
 from config.bos import bos_config_convert, general_config_convert_bos
-import logging
+
 from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
 
 
 class BOSMiner(BaseMiner):
     def __init__(self, ip: str) -> None:
-        api = BOSMinerAPI(ip)
-        super().__init__(ip, api)
-        self.model = None
-        self.config = None
-        self.version = None
+        super().__init__(ip)
+        self.ip = ipaddress.ip_address(ip)
+        self.api = BOSMinerAPI(ip)
+        self.api_type = "BOSMiner"
         self.uname = "root"
         self.pwd = "admin"
-        self.nominal_chips = 63
-
-    def __repr__(self) -> str:
-        return f"BOSminer: {str(self.ip)}"
+        self.config = None
 
     async def send_ssh_command(self, cmd: str) -> str or None:
         """Send a command to the miner over ssh.
@@ -117,7 +123,7 @@ class BOSMiner(BaseMiner):
                 else:
                     logging.warning(f"Failed to get hostname for miner: {self}")
                     return "?"
-        except Exception as e:
+        except Exception:
             logging.warning(f"Failed to get hostname for miner: {self}")
             return "?"
 
@@ -132,7 +138,17 @@ class BOSMiner(BaseMiner):
             return self.model + " (BOS)"
 
         # get devdetails data
-        version_data = await self.api.devdetails()
+        try:
+            version_data = await self.api.devdetails()
+        except APIError as e:
+            version_data = None
+            if e.message == "Not ready":
+                cfg = json.loads(await self.send_ssh_command("bosminer config --data"))
+                model = cfg.get("data").get("format").get("model")
+                if model:
+                    model = model.replace("Antminer ", "")
+                    self.model = model
+                    return self.model + " (BOS)"
 
         # if we get data back, parse it for model
         if version_data:
@@ -163,7 +179,7 @@ class BOSMiner(BaseMiner):
 
         # if we get the version data, parse it
         if version_data:
-            self.version = version_data.stdout.split("-")[5]
+            self.version = version_data.split("-")[5]
             logging.debug(f"Found version for {self.ip}: {self.version}")
             return self.version
 
@@ -240,59 +256,73 @@ class BOSMiner(BaseMiner):
         if not bad > 0:
             return str(self.ip)
 
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": "0",
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
+    async def get_data(self) -> MinerData:
+        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()
 
         if model:
-            data["Model"] = model
+            data.model = model
 
         if hostname:
-            data["Hostname"] = hostname
+            data.hostname = hostname
+
+        if mac:
+            data.mac = mac
 
         miner_data = None
         for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand(
-                "summary", "temps", "tunerstatus", "pools"
-            )
+            try:
+                miner_data = await self.api.multicommand(
+                    "summary", "temps", "tunerstatus", "pools", "devdetails", "fans"
+                )
+            except APIError as e:
+                if str(e.message) == "Not ready":
+                    miner_data = await self.api.multicommand(
+                        "summary", "tunerstatus", "pools", "fans"
+                    )
             if miner_data:
                 break
         if not miner_data:
             return data
-        summary = miner_data.get("summary")[0]
-        temps = miner_data.get("temps")[0]
-        tunerstatus = miner_data.get("tunerstatus")[0]
-        pools = miner_data.get("pools")[0]
+        summary = miner_data.get("summary")
+        temps = miner_data.get("temps")
+        tunerstatus = miner_data.get("tunerstatus")
+        pools = miner_data.get("pools")
+        devdetails = miner_data.get("devdetails")
+        fans = miner_data.get("fans")
 
         if summary:
-            hr = summary.get("SUMMARY")
+            hr = summary[0].get("SUMMARY")
             if hr:
                 if len(hr) > 0:
-                    hr = hr[0].get("MHS 5s")
+                    hr = hr[0].get("MHS 1m")
                     if hr:
-                        data["Hashrate"] = round(hr / 1000000, 2)
+                        data.hashrate = round(hr / 1000000, 2)
 
         if temps:
-            temp = temps.get("TEMPS")
+            temp = temps[0].get("TEMPS")
             if temp:
                 if len(temp) > 0:
-                    temp = temp[0].get("Chip")
-                    if temp:
-                        data["Temperature"] = round(temp)
+                    board_map = {0: "left_board", 1: "center_board", 2: "right_board"}
+                    offset = 6 if temp[0]["ID"] in [6, 7, 8] else temp[0]["ID"]
+                    for board in temp:
+                        _id = board["ID"] - offset
+                        chip_temp = round(board["Chip"])
+                        board_temp = round(board["Board"])
+                        setattr(data, f"{board_map[_id]}_chip_temp", chip_temp)
+                        setattr(data, f"{board_map[_id]}_temp", board_temp)
+
+        if fans:
+            fan_data = fans[0].get("FANS")
+            if fan_data:
+                for fan in range(self.fan_count):
+                    setattr(data, f"fan_{fan+1}", fan_data[fan]["RPM"])
 
         if pools:
             pool_1 = None
@@ -302,7 +332,7 @@ class BOSMiner(BaseMiner):
             pool_1_quota = 1
             pool_2_quota = 1
             quota = 0
-            for pool in pools.get("POOLS"):
+            for pool in pools[0].get("POOLS"):
                 if not pool_1_user:
                     pool_1_user = pool.get("User")
                     pool_1 = pool["URL"]
@@ -320,31 +350,47 @@ class BOSMiner(BaseMiner):
                 quota = f"{pool_1_quota}/{pool_2_quota}"
 
             if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "")
-                pool_1 = pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = 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
-                data["Pool User"] = pool_1_user
+                data.pool_1_user = pool_1_user
 
             if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "")
-                pool_2 = pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = 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
+                data.pool_2_user = pool_2_user
 
             if quota:
-                data["Split"] = str(quota)
+                data.pool_split = str(quota)
 
         if tunerstatus:
-            tuner = tunerstatus.get("TUNERSTATUS")
+            tuner = tunerstatus[0].get("TUNERSTATUS")
             if tuner:
                 if len(tuner) > 0:
                     wattage = tuner[0].get("PowerLimit")
                     if wattage:
-                        data["Wattage"] = wattage
+                        data.wattage = wattage
+
+        if devdetails:
+            boards = devdetails[0].get("DEVDETAILS")
+            if boards:
+                if len(boards) > 0:
+                    board_map = {0: "left_chips", 1: "center_chips", 2: "right_chips"}
+                    offset = 6 if boards[0]["ID"] in [6, 7, 8] else boards[0]["ID"]
+                    for board in boards:
+                        _id = board["ID"] - offset
+                        chips = board["Chips"]
+                        setattr(data, board_map[_id], chips)
 
         return data
+
+    async def get_mac(self):
+        result = await self.send_ssh_command("cat /sys/class/net/eth0/address")
+        return result.upper()

miners/_backends/bosminer_old.py

@@ -0,0 +1,45 @@
+import logging
+
+import asyncssh
+
+from API.bosminer import BOSMinerAPI
+from miners import BaseMiner
+
+
+class BOSMinerOld(BaseMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.api = BOSMinerAPI(ip)
+        self.api_type = "BOSMiner"
+        self.uname = "root"
+        self.pwd = "admin"
+
+    async def send_ssh_command(self, cmd: str) -> str or None:
+        """Send a command to the miner over ssh.
+
+        :return: Result of the command or None.
+        """
+        result = None
+
+        # open an ssh connection
+        async with await asyncssh.connect("192.168.1.11", username="root") as conn:
+            # 3 retries
+            for i in range(3):
+                try:
+                    # run the command and get the result
+                    result = await conn.run(cmd)
+                    result = result.stdout
+                except Exception as e:
+                    # if the command fails, log it
+                    logging.warning(f"{self} command {cmd} error: {e}")
+
+                    # on the 3rd retry, return None
+                    if i == 3:
+                        return
+                    continue
+        # return the result, either command output or None
+        return str(result)
+
+    async def update_to_plus(self):
+        result = await self.send_ssh_command("opkg update && opkg install bos_plus")
+        return result

miners/_backends/btminer.py

@@ -1,19 +1,22 @@
+import ipaddress
+import logging
+
+
 from API.btminer import BTMinerAPI
 from miners import BaseMiner
 from API import APIError
-import logging
+
+from data import MinerData
+
 from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
 
 
 class BTMiner(BaseMiner):
     def __init__(self, ip: str) -> None:
-        api = BTMinerAPI(ip)
-        self.model = None
-        super().__init__(ip, api)
-        self.nominal_chips = 66
-
-    def __repr__(self) -> str:
-        return f"BTMiner: {str(self.ip)}"
+        super().__init__(ip)
+        self.ip = ipaddress.ip_address(ip)
+        self.api = BTMinerAPI(ip)
+        self.api_type = "BTMiner"
 
     async def get_model(self):
         if self.model:
@@ -38,9 +41,9 @@ class BTMiner(BaseMiner):
                 self.hostname = host
                 return self.hostname
         except APIError:
-            logging.warning(f"Failed to get hostname for miner: {self}")
+            logging.info(f"Failed to get hostname for miner: {self}")
             return "?"
-        except Exception as e:
+        except Exception:
             logging.warning(f"Failed to get hostname for miner: {self}")
             return "?"
 
@@ -75,35 +78,60 @@ class BTMiner(BaseMiner):
         logging.debug(f"Found board data for {self}: {boards}")
         return boards
 
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": 0,
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
+    async def get_mac(self):
+        mac = ""
+        data = await self.api.summary()
+        if data:
+            if data.get("SUMMARY"):
+                if len(data["SUMMARY"]) > 0:
+                    _mac = data["SUMMARY"][0].get("MAC")
+                    if _mac:
+                        mac = _mac
+        if mac == "":
+            try:
+                data = await self.api.get_miner_info()
+                if data:
+                    if "Msg" in data.keys():
+                        if "mac" in data["Msg"].keys():
+                            mac = data["Msg"]["mac"]
+            except APIError:
+                pass
 
-        model = await self.get_model()
-        hostname = await self.get_hostname()
+        return str(mac).upper()
+
+    async def get_data(self):
+        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
+
+        mac = None
+
+        try:
+            model = await self.get_model()
+        except APIError:
+            logging.info(f"Failed to get model: {self}")
+            model = None
+            data.model = "Whatsminer"
+
+        try:
+            hostname = await self.get_hostname()
+        except APIError:
+            logging.info(f"Failed to get hostname: {self}")
+            hostname = None
+            data.hostname = "Whatsminer"
 
         if model:
-            data["Model"] = model
+            data.model = model
 
         if hostname:
-            data["Hostname"] = hostname
+            data.hostname = hostname
+
         miner_data = None
         for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand("summary", "devs", "pools")
-            if miner_data:
-                break
+            try:
+                miner_data = await self.api.multicommand("summary", "devs", "pools")
+                if miner_data:
+                    break
+            except APIError:
+                pass
 
         if not miner_data:
             return data
@@ -116,22 +144,45 @@ class BTMiner(BaseMiner):
             summary_data = summary.get("SUMMARY")
             if summary_data:
                 if len(summary_data) > 0:
-                    hr = summary_data[0].get("MHS 5s")
+                    if summary_data[0].get("MAC"):
+                        mac = summary_data[0]["MAC"]
+
+                    data.fan_1 = summary_data[0]["Fan Speed In"]
+                    data.fan_2 = summary_data[0]["Fan Speed Out"]
+
+                    hr = summary_data[0].get("MHS 1m")
                     if hr:
-                        data["Hashrate"] = round(hr / 1000000, 2)
+                        data.hashrate = round(hr / 1000000, 2)
 
                     wattage = summary_data[0].get("Power")
                     if wattage:
-                        data["Wattage"] = round(wattage)
+                        data.wattage = round(wattage)
 
         if devs:
             temp_data = devs.get("DEVS")
             if temp_data:
+                board_map = {0: "left_board", 1: "center_board", 2: "right_board"}
                 for board in temp_data:
-                    temp = board.get("Chip Temp Avg")
-                    if temp and not temp == 0.0:
-                        data["Temperature"] = round(temp)
-                        break
+                    _id = board["ASC"]
+                    chip_temp = round(board["Chip Temp Avg"])
+                    board_temp = round(board["Temperature"])
+                    setattr(data, f"{board_map[_id]}_chip_temp", chip_temp)
+                    setattr(data, f"{board_map[_id]}_temp", board_temp)
+
+        if devs:
+            boards = devs.get("DEVS")
+            if boards:
+                if len(boards) > 0:
+                    board_map = {0: "left_chips", 1: "center_chips", 2: "right_chips"}
+                    if "ID" in boards[0].keys():
+                        id_key = "ID"
+                    else:
+                        id_key = "ASC"
+                    offset = boards[0][id_key]
+                    for board in boards:
+                        _id = board[id_key] - offset
+                        chips = board["Effective Chips"]
+                        setattr(data, board_map[_id], chips)
 
         if pools:
             pool_1 = None
@@ -159,27 +210,34 @@ class BTMiner(BaseMiner):
                 quota = f"{pool_1_quota}/{pool_2_quota}"
 
             if pool_1:
-                if pool_1.startswith("stratum+tcp://"):
-                    pool_1.replace("stratum+tcp://", "")
-                if pool_1.startswith("stratum2+tcp://"):
-                    pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = 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
-                data["Pool User"] = pool_1_user
+                data.pool_1_user = pool_1_user
 
             if pool_2:
-                if pool_2.startswith("stratum+tcp://"):
-                    pool_2.replace("stratum+tcp://", "")
-                if pool_2.startswith("stratum2+tcp://"):
-                    pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = 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
+                data.pool_2_user = pool_2_user
 
             if quota:
-                data["Split"] = str(quota)
+                data.pool_split = str(quota)
+
+        if not mac:
+            try:
+                mac = await self.get_mac()
+            except APIError:
+                logging.info(f"Failed to get mac: {self}")
+                mac = None
+
+            if mac:
+                data.mac = mac
 
         return data

miners/_backends/cgminer.py

@@ -1,21 +1,25 @@
-from miners import BaseMiner
-from API.cgminer import CGMinerAPI
-from API import APIError
-from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
+import ipaddress
 import logging
 
 
+from API.cgminer import CGMinerAPI
+from miners import BaseMiner
+from API import APIError
+
+from data import MinerData
+
+from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
+
+
 class CGMiner(BaseMiner):
     def __init__(self, ip: str) -> None:
-        api = CGMinerAPI(ip)
-        super().__init__(ip, api)
-        self.model = None
-        self.config = None
+        super().__init__(ip)
+        self.ip = ipaddress.ip_address(ip)
+        self.api = CGMinerAPI(ip)
+        self.api_type = "CGMiner"
         self.uname = "root"
         self.pwd = "admin"
-
-    def __repr__(self) -> str:
-        return f"CGMiner: {str(self.ip)}"
+        self.config = None
 
     async def get_model(self):
         if self.model:
@@ -105,29 +109,21 @@ class CGMiner(BaseMiner):
             print(str(self.config))
 
     async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": 0,
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
+        data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
 
         model = await self.get_model()
         hostname = await self.get_hostname()
+        mac = await self.get_mac()
 
         if model:
-            data["Model"] = model
+            data.model = model
 
         if hostname:
-            data["Hostname"] = hostname
+            data.hostname = hostname
+
+        if mac:
+            data.mac = mac
+
         miner_data = None
         for i in range(DATA_RETRIES):
             miner_data = await self.api.multicommand("summary", "pools", "stats")
@@ -145,18 +141,25 @@ class CGMiner(BaseMiner):
             hr = summary.get("SUMMARY")
             if hr:
                 if len(hr) > 0:
-                    hr = hr[0].get("GHS 5s")
+                    hr = hr[0].get("GHS 1m")
                     if hr:
-                        data["Hashrate"] = round(hr / 1000, 2)
+                        data.hashrate = round(hr / 1000, 2)
 
         if stats:
             temp = stats.get("STATS")
             if temp:
                 if len(temp) > 1:
-                    for item in ["temp2", "temp1", "temp3"]:
-                        temperature = temp[1].get(item)
-                        if temperature and not temperature == 0.0:
-                            data["Temperature"] = round(temperature)
+                    data.fan_1 = temp[1].get("fan1")
+                    data.fan_2 = temp[1].get("fan2")
+                    data.fan_3 = temp[1].get("fan3")
+                    data.fan_4 = temp[1].get("fan4")
+
+                    board_map = {1: "left_board", 2: "center_board", 3: "right_board"}
+                    for item in range(1, 4):
+                        board_temp = temp[1].get(f"temp{item}")
+                        chip_temp = temp[1].get(f"temp2_{item}")
+                        setattr(data, f"{board_map[item]}_chip_temp", chip_temp)
+                        setattr(data, f"{board_map[item]}_temp", board_temp)
 
         if pools:
             pool_1 = None
@@ -184,27 +187,24 @@ class CGMiner(BaseMiner):
                 quota = f"{pool_1_quota}/{pool_2_quota}"
 
             if pool_1:
-                if pool_1.startswith("stratum+tcp://"):
-                    pool_1.replace("stratum+tcp://", "")
-                if pool_1.startswith("stratum2+tcp://"):
-                    pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = 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
-                data["Pool User"] = pool_1_user
+                data.pool_1_user = pool_1_user
 
             if pool_2:
-                if pool_2.startswith("stratum+tcp://"):
-                    pool_2.replace("stratum+tcp://", "")
-                if pool_2.startswith("stratum2+tcp://"):
-                    pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = 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
+                data.pool_2_user = pool_2_user
 
             if quota:
-                data["Split"] = str(quota)
+                data.pool_split = str(quota)
 
         return data

miners/_backends/hiveon.py

@@ -1,14 +1,14 @@
-from miners.bmminer import BMMiner
+from miners._backends import BMMiner
+import ipaddress
 
 
-class HiveonT9(BMMiner):
+class Hiveon(BMMiner):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
-        self.model = "T9"
+        self.ip = ipaddress.ip_address(ip)
         self.api_type = "Hiveon"
-
-    def __repr__(self) -> str:
-        return f"HiveonT9: {str(self.ip)}"
+        self.uname = "root"
+        self.pwd = "admin"
 
     async def get_board_info(self) -> dict:
         """Gets data on each board and chain in the miner."""

miners/_types/__init__.py

@@ -0,0 +1,3 @@
+from .antminer import *
+from .avalonminer import *
+from .whatsminer import *

miners/_types/antminer/X17/S17.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S17(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S17"
+        self.nominal_chips = 48
+        self.fan_count = 4

miners/_types/antminer/X17/S17_Plus.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S17Plus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S17+"
+        self.nominal_chips = 65
+        self.fan_count = 4

miners/_types/antminer/X17/S17_Pro.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S17Pro(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S17 Pro"
+        self.nominal_chips = 48
+        self.fan_count = 4

miners/_types/antminer/X17/S17e.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S17e(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S17e"
+        self.nominal_chips = 135
+        self.fan_count = 4

miners/_types/antminer/X17/T17.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class T17(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "T17"
+        self.nominal_chips = 30
+        self.fan_count = 4

miners/_types/antminer/X17/T17_Plus.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class T17Plus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "T17+"
+        self.nominal_chips = 44
+        self.fan_count = 4

miners/_types/antminer/X17/T17e.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class T17e(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "T17e"
+        self.nominal_chips = 78
+        self.fan_count = 4

miners/_types/antminer/X17/__init__.py

@@ -0,0 +1,8 @@
+from .S17 import S17
+from .S17_Plus import S17Plus
+from .S17_Pro import S17Pro
+from .S17e import S17e
+
+from .T17 import T17
+from .T17_Plus import T17Plus
+from .T17e import T17e

miners/_types/antminer/X19/S19.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S19(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S19"
+        self.nominal_chips = 76
+        self.fan_count = 4

miners/_types/antminer/X19/S19_Pro.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S19Pro(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S19 Pro"
+        self.nominal_chips = 114
+        self.fan_count = 4

miners/_types/antminer/X19/S19a.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S19a(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S19a"
+        self.nominal_chips = 72
+        self.fan_count = 4

miners/_types/antminer/X19/S19j.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S19j(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S19j"
+        self.nominal_chips = 114
+        self.fan_count = 4

miners/_types/antminer/X19/S19j_Pro.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S19jPro(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S19j Pro"
+        self.nominal_chips = 126
+        self.fan_count = 4

miners/_types/antminer/X19/T19.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class T19(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "T19"
+        self.nominal_chips = 76
+        self.fan_count = 4

miners/_types/antminer/X19/__init__.py

@@ -0,0 +1,9 @@
+from .S19 import S19
+from .S19_Pro import S19Pro
+
+from .S19j import S19j
+from .S19j_Pro import S19jPro
+
+from .S19a import S19a
+
+from .T19 import T19

miners/_types/antminer/X9/S9.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S9(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S9"
+        self.nominal_chips = 63
+        self.fan_count = 2

miners/_types/antminer/X9/S9i.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class S9i(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S9i"
+        self.nominal_chips = 63
+        self.fan_count = 2

miners/_types/antminer/X9/T9.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class T9(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "T9"
+        self.nominal_chips = 57
+        self.fan_count = 2

miners/_types/antminer/X9/__init__.py

@@ -0,0 +1,3 @@
+from .S9 import S9
+from .S9i import S9i
+from .T9 import T9

miners/_types/antminer/__init__.py

@@ -0,0 +1,3 @@
+from .X9 import *
+from .X17 import *
+from .X19 import *

miners/_types/avalonminer/A10X/A1047.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon1047(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 1047"
+        self.nominal_chips = 114
+        self.fan_count = 4

miners/_types/avalonminer/A10X/A1066.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon1066(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 1066"
+        self.nominal_chips = 114
+        self.fan_count = 4

miners/_types/avalonminer/A10X/__init__.py

@@ -0,0 +1,2 @@
+from .A1047 import Avalon1047
+from .A1066 import Avalon1066

miners/_types/avalonminer/A8X/A821.py

@@ -0,0 +1,9 @@
+from miners import BaseMiner
+
+
+class Avalon821(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 821"
+        self.fan_count = 2

miners/_types/avalonminer/A8X/A841.py

@@ -0,0 +1,9 @@
+from miners import BaseMiner
+
+
+class Avalon841(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 841"
+        self.fan_count = 2

miners/_types/avalonminer/A8X/__init__.py

@@ -0,0 +1,2 @@
+from .A821 import Avalon821
+from .A841 import Avalon841

miners/_types/avalonminer/__init__.py

@@ -0,0 +1,2 @@
+from .A8X import *
+from .A10X import *

miners/_types/whatsminer/M2X/M20S.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class M20S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M20S"
+        self.nominal_chips = 66
+        self.fan_count = 2

miners/_types/whatsminer/M2X/M20S_Plus.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class M20SPlus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M20S+"
+        self.nominal_chips = 66
+        self.fan_count = 2

miners/_types/whatsminer/M2X/M21.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class M21(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M21"
+        self.nominal_chips = 105
+        self.fan_count = 2

miners/_types/whatsminer/M2X/M21S.py

@@ -0,0 +1,19 @@
+from miners import BaseMiner
+
+
+class M21SV60(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M21S V60"
+        self.nominal_chips = 105
+        self.fan_count = 2
+
+
+class M21SV20(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M21S V20"
+        self.nominal_chips = 66
+        self.fan_count = 2

miners/_types/whatsminer/M2X/M21S_Plus.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class M21SPlus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M21S+"
+        self.nominal_chips = 105
+        self.fan_count = 2

miners/_types/whatsminer/M2X/__init__.py

@@ -0,0 +1,6 @@
+from .M20S import M20S
+from .M20S_Plus import M20SPlus
+
+from .M21 import M21
+from .M21S import M21SV20, M21SV60
+from .M21S_Plus import M21SPlus

miners/_types/whatsminer/M3X/M30S.py

@@ -0,0 +1,19 @@
+from miners import BaseMiner
+
+
+class M30S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S"
+        self.nominal_chips = 148
+        self.fan_count = 2
+
+
+class M30SV50(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S V50"
+        self.nominal_chips = 156
+        self.fan_count = 2

miners/_types/whatsminer/M3X/M30S_Plus.py

@@ -0,0 +1,19 @@
+from miners import BaseMiner
+
+
+class M30SPlus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S+"
+        self.nominal_chips = 156
+        self.fan_count = 2
+
+
+class M30SPlusVE40(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S+ VE40"
+        self.nominal_chips = 156
+        self.fan_count = 2

miners/_types/whatsminer/M3X/M30S_Plus_Plus.py

@@ -0,0 +1,19 @@
+from miners import BaseMiner
+
+
+class M30SPlusPlusVG30(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S++ V30"
+        self.nominal_chips = 111
+        self.fan_count = 2
+
+
+class M30SPlusPlusVG40(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S++ V40"
+        self.nominal_chips = 117
+        self.fan_count = 2

miners/_types/whatsminer/M3X/M31S.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class M31S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M31S"
+        # TODO: Add chip count for this miner (per board) - self.nominal_chips
+        self.fan_count = 2

miners/_types/whatsminer/M3X/M31S_Plus.py

@@ -0,0 +1,19 @@
+from miners import BaseMiner
+
+
+class M31SPlus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M31S+"
+        self.nominal_chips = 78
+        self.fan_count = 2
+
+
+class M31SPlusVE20(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M31S+ VE20"
+        self.nominal_chips = 78
+        self.fan_count = 2

miners/_types/whatsminer/M3X/M32S.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class M32S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M32S"
+        self.nominal_chips = 78
+        self.fan_count = 2

miners/_types/whatsminer/M3X/__init__.py

@@ -0,0 +1,8 @@
+from .M30S import M30S, M30SV50
+from .M30S_Plus import M30SPlus, M30SPlusVE40
+from .M30S_Plus_Plus import M30SPlusPlusVG30, M30SPlusPlusVG40
+
+from .M31S import M31S
+from .M31S_Plus import M31SPlus, M31SPlusVE20
+
+from .M32S import M32S

miners/_types/whatsminer/__init__.py

@@ -0,0 +1,2 @@
+from .M2X import *
+from .M3X import *

miners/antminer/S9/bmminer.py

@@ -1,11 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-class BMMinerS9(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "S9"
-        self.api_type = "BMMiner"
-
-    def __repr__(self) -> str:
-        return f"BMMinerS9: {str(self.ip)}"

miners/antminer/S9/bosminer.py

@@ -1,15 +0,0 @@
-import logging
-import toml
-
-from miners.bosminer import BOSMiner
-from config.bos import general_config_convert_bos
-
-
-class BOSMinerS9(BOSMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "S9"
-        self.api_type = "BOSMiner"
-
-    def __repr__(self) -> str:
-        return f"BOSminerS9: {str(self.ip)}"

miners/antminer/S9/cgminer.py

@@ -1,11 +0,0 @@
-from miners.cgminer import CGMiner
-
-
-class CGMinerS9(CGMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "S9"
-        self.api_type = "CGMiner"
-
-    def __repr__(self) -> str:
-        return f"CGMinerS9: {str(self.ip)}"

miners/antminer/T9/bmminer.py

@@ -1,11 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-class BMMinerT9(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "T9"
-        self.api_type = "BMMiner"
-
-    def __repr__(self) -> str:
-        return f"BMMinerT9: {str(self.ip)}"

miners/antminer/T9/cgminer.py

@@ -1,11 +0,0 @@
-from miners.cgminer import CGMiner
-
-
-class CGMinerT9(CGMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "T9"
-        self.api_type = "CGMiner"
-
-    def __repr__(self) -> str:
-        return f"CGMinerT9: {str(self.ip)}"

miners/antminer/X17/bmminer.py

@@ -1,9 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-class BMMinerX17(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-
-    def __repr__(self) -> str:
-        return f"BMMinerX17: {str(self.ip)}"

miners/antminer/X17/bosminer.py

@@ -1,11 +0,0 @@
-from miners.bosminer import BOSMiner
-
-
-class BOSMinerX17(BOSMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.api_type = "BOSMiner"
-        self.nominal_chips = 65
-
-    def __repr__(self) -> str:
-        return f"BOSminerX17: {str(self.ip)}"

miners/antminer/X17/cgminer.py

@@ -1,10 +0,0 @@
-from miners.cgminer import CGMiner
-
-
-class CGMinerX17(CGMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.api_type = "CGMiner"
-
-    def __repr__(self) -> str:
-        return f"CGMinerX17: {str(self.ip)}"

miners/antminer/X19/bmminer.py

@@ -1,22 +0,0 @@
-from miners.bmminer import BMMiner
-import logging
-
-
-class BMMinerX19(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-
-    def __repr__(self) -> str:
-        return f"BMMinerX19: {str(self.ip)}"
-
-    async def get_model(self):
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-        version_data = await self.api.version()
-        if version_data:
-            self.model = version_data["VERSION"][0]["Type"].replace("Antminer ", "")
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None

miners/antminer/X19/bosminer.py

@@ -1,11 +0,0 @@
-from miners.bosminer import BOSMiner
-
-
-class BOSMinerX19(BOSMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.api_type = "BOSMiner"
-        self.nominal_chips = 114
-
-    def __repr__(self) -> str:
-        return f"BOSminerX19: {str(self.ip)}"

miners/antminer/X19/cgminer.py

@@ -1,23 +0,0 @@
-from miners.cgminer import CGMiner
-import logging
-
-
-class CGMinerX19(CGMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.api_type = "CGMiner"
-
-    def __repr__(self) -> str:
-        return f"CGMinerX19: {str(self.ip)}"
-
-    async def get_model(self):
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-        version_data = await self.api.version()
-        if version_data:
-            self.model = version_data["VERSION"][0]["Type"].replace("Antminer ", "")
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None

miners/antminer/__init__.py

@@ -0,0 +1,4 @@
+from .bmminer import *
+from .bosminer import *
+from .cgminer import *
+from .hiveon import *

miners/antminer/bmminer/X17/S17.py

@@ -0,0 +1,87 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S17  # noqa - Ignore access to _module
+
+import httpx
+
+
+# TODO add config
+
+
+class BMMinerS17(BMMiner, S17):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/S17_Plus.py

@@ -0,0 +1,84 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S17Plus  # noqa - Ignore access to _module
+
+import httpx
+
+
+class BMMinerS17Plus(BMMiner, S17Plus):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/S17_Pro.py

@@ -0,0 +1,84 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S17Pro  # noqa - Ignore access to _module
+
+import httpx
+
+
+class BMMinerS17Pro(BMMiner, S17Pro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/S17e.py

@@ -0,0 +1,84 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S17e  # noqa - Ignore access to _module
+
+import httpx
+
+
+class BMMinerS17e(BMMiner, S17e):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/T17.py

@@ -0,0 +1,84 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import T17  # noqa - Ignore access to _module
+
+import httpx
+
+
+class BMMinerT17(BMMiner, T17):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/T17_Plus.py

@@ -0,0 +1,84 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import T17Plus  # noqa - Ignore access to _module
+
+import httpx
+
+
+class BMMinerT17Plus(BMMiner, T17Plus):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/T17e.py

@@ -0,0 +1,84 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import T17e  # noqa - Ignore access to _module
+
+import httpx
+
+
+class BMMinerT17e(BMMiner, T17e):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            try:
+                await client.post(url, data={"action": "startBlink"}, auth=auth)
+            except httpx.ReadTimeout:
+                # Expected behaviour
+                pass
+            data = await client.post(url, data={"action": "onPageLoaded"}, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data["isBlinking"]:
+                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")
+        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"]:
+                return True
+        return False
+
+    async def check_light(self):
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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"]:
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X17/__init__.py

@@ -0,0 +1,8 @@
+from .S17 import BMMinerS17
+from .S17_Plus import BMMinerS17Plus
+from .S17_Pro import BMMinerS17Pro
+from .S17e import BMMinerS17e
+
+from .T17 import BMMinerT17
+from .T17_Plus import BMMinerT17Plus
+from .T17e import BMMinerT17e

miners/antminer/bmminer/X19/S19.py

@@ -0,0 +1,73 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S19  # noqa - Ignore access to _module
+
+import httpx
+import json
+
+
+# TODO add config
+
+
+class BMMinerS19(BMMiner, S19):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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":
+                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")
+        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":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X19/S19_Pro.py

@@ -0,0 +1,70 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S19Pro  # noqa - Ignore access to _module
+
+import httpx
+import json
+
+
+class BMMinerS19Pro(BMMiner, S19Pro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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":
+                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")
+        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":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X19/S19a.py

@@ -0,0 +1,70 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S19a  # noqa - Ignore access to _module
+
+import httpx
+import json
+
+
+class BMMinerS19a(BMMiner, S19a):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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":
+                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")
+        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":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X19/S19j.py

@@ -0,0 +1,70 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S19j  # noqa - Ignore access to _module
+
+import httpx
+import json
+
+
+class BMMinerS19j(BMMiner, S19j):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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":
+                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")
+        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":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X19/S19j_Pro.py

@@ -0,0 +1,70 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S19jPro  # noqa - Ignore access to _module
+
+import httpx
+import json
+
+
+class BMMinerS19jPro(BMMiner, S19jPro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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":
+                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")
+        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":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X19/T19.py

@@ -0,0 +1,70 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import T19  # noqa - Ignore access to _module
+
+import httpx
+import json
+
+
+class BMMinerT19(BMMiner, T19):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        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":
+                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")
+        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":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/antminer/bmminer/X19/__init__.py

@@ -0,0 +1,9 @@
+from .S19 import BMMinerS19
+from .S19_Pro import BMMinerS19Pro
+
+from .S19j import BMMinerS19j
+from .S19j_Pro import BMMinerS19jPro
+
+from .S19a import BMMinerS19a
+
+from .T19 import BMMinerT19

miners/antminer/bmminer/X9/S9.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S9  # noqa - Ignore access to _module
+
+
+class BMMinerS9(BMMiner, S9):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X9/S9i.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import S9i  # noqa - Ignore access to _module
+
+
+class BMMinerS9i(BMMiner, S9i):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X9/T9.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+from miners._types import T9  # noqa - Ignore access to _module
+
+
+class BMMinerT9(BMMiner, T9):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X9/__init__.py

@@ -0,0 +1,3 @@
+from .S9 import BMMinerS9
+from .S9i import BMMinerS9i
+from .T9 import BMMinerT9

miners/antminer/bmminer/__init__.py

@@ -0,0 +1,3 @@
+from .X9 import *
+from .X17 import *
+from .X19 import *

miners/antminer/bosminer/X17/S17.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner  # noqa - Ignore access to _module
+from miners._types import S17  # noqa - Ignore access to _module
+
+
+class BOSMinerS17(BOSMiner, S17):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bosminer/X17/S17_Plus.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner  # noqa - Ignore access to _module
+from miners._types import S17Plus  # noqa - Ignore access to _module
+
+
+class BOSMinerS17Plus(BOSMiner, S17Plus):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bosminer/X17/S17_Pro.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner  # noqa - Ignore access to _module
+from miners._types import S17Pro  # noqa - Ignore access to _module
+
+
+class BOSMinerS17Pro(BOSMiner, S17Pro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip