update README.md

# Conflicts:
#	miners/bosminer.py
#	tools/bad_board_util/func/decorators.py
#	tools/bad_board_util/layout.py
#	tools/bad_board_util/ui.py

.dockerignore

@@ -0,0 +1,8 @@
+# Ignore VENV
+venv
+
+# Ignore builds
+build
+
+# Ignore github files
+.github

API/__init__.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import ipaddress
 import warnings
+import logging
 
 
 class APIError(Exception):
@@ -41,36 +42,44 @@ class BaseMinerAPI:
 
     def get_commands(self) -> list:
         """Get a list of command accessible to a specific type of API on the miner."""
-        return [func for func in
-                # each function in self
-                dir(self) if callable(getattr(self, func)) and
-                # no __ methods
-                not func.startswith("__") and
-                # remove all functions that are in this base class
-                func not in
-                [func for func in
-                 dir(BaseMinerAPI) if callable(getattr(BaseMinerAPI, func))
-                 ]
-                ]
+        return [
+            func
+            for func in
+            # each function in self
+            dir(self)
+            if callable(getattr(self, func)) and
+            # no __ methods
+            not func.startswith("__") and
+            # remove all functions that are in this base class
+            func
+            not in [
+                func
+                for func in dir(BaseMinerAPI)
+                if callable(getattr(BaseMinerAPI, func))
+            ]
+        ]
 
     async def multicommand(self, *commands: str) -> 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
         user_commands = [*commands]
         allowed_commands = self.get_commands()
         # make sure we can actually run the command, otherwise it will fail
         commands = [command for command in user_commands if command in allowed_commands]
         for item in list(set(user_commands) - set(commands)):
-            warnings.warn(f"""Removing incorrect command: {item}
+            warnings.warn(
+                f"""Removing incorrect command: {item}
 If you are sure you want to use this command please use API.send_command("{item}", ignore_errors=True) instead.""",
-                          APIWarning)
+                APIWarning,
+            )
         # standard multicommand format is "command1+command2"
         # doesnt work for S19 which is dealt with in the send command function
         command = "+".join(commands)
         data = None
         try:
             data = await self.send_command(command)
-        except APIError:
+        except APIError as e:
             try:
                 data = {}
                 # S19 handler, try again
@@ -80,11 +89,17 @@ If you are sure you want to use this command please use API.send_command("{item}
             except APIError as e:
                 raise APIError(e)
             except Exception as e:
-                print(e)
+                logging.warning(f"{self.ip}: API Multicommand Error: {e}")
         if data:
+            logging.debug(f"{self.ip}: Received multicommand data.")
             return data
 
-    async def send_command(self, command: str, parameters: str or int or bool = None, ignore_errors: bool = False) -> dict:
+    async def send_command(
+        self,
+        command: str,
+        parameters: str or int or bool = None,
+        ignore_errors: bool = False,
+    ) -> dict:
         """Send an API command to the miner and return the result."""
         try:
             # get reader and writer streams
@@ -92,7 +107,7 @@ If you are sure you want to use this command please use API.send_command("{item}
         # handle OSError 121
         except OSError as e:
             if e.winerror == "121":
-                print("Semaphore Timeout has Expired.")
+                logging.warning("Semaphore Timeout has Expired.")
             return {}
 
         # create the command
@@ -101,7 +116,7 @@ If you are sure you want to use this command please use API.send_command("{item}
             cmd["parameter"] = parameters
 
         # send the command
-        writer.write(json.dumps(cmd).encode('utf-8'))
+        writer.write(json.dumps(cmd).encode("utf-8"))
         await writer.drain()
 
         # instantiate data
@@ -115,7 +130,7 @@ If you are sure you want to use this command please use API.send_command("{item}
                     break
                 data += d
         except Exception as e:
-            print(e)
+            logging.warning(f"{self.ip}: API Command Error: {e}")
 
         data = self.load_api_data(data)
 
@@ -128,12 +143,13 @@ 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]}")
                 raise APIError(validation[1])
 
         return data
 
     @staticmethod
-    def validate_command_output(data: dict) -> tuple[bool, str | None]:
+    def validate_command_output(data: dict) -> tuple:
         """Check if the returned command output is correctly formatted."""
         # check if the data returned is correct or an error
         # if status isn't a key, it is a multicommand
@@ -160,14 +176,15 @@ If you are sure you want to use this command please use API.send_command("{item}
     @staticmethod
     def load_api_data(data: bytes) -> dict:
         """Convert API data from JSON to dict"""
+        str_data = None
         try:
             # some json from the API returns with a null byte (\x00) on the end
             if data.endswith(b"\x00"):
                 # handle the null byte
-                str_data = data.decode('utf-8')[:-1]
+                str_data = data.decode("utf-8")[:-1]
             else:
                 # no null byte
-                str_data = data.decode('utf-8')
+                str_data = data.decode("utf-8")
             # fix an error with a btminer return having an extra comma that breaks json.loads()
             str_data = str_data.replace(",}", "}")
             # fix an error with a btminer return having a newline that breaks json.loads()
@@ -176,10 +193,11 @@ 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
         except json.decoder.JSONDecodeError as e:
-            print(e)
-            raise APIError(f"Decode Error: {str_data}")
+            raise APIError(f"Decode Error {e}: {str_data}")
         return parsed_data

API/bmminer.py

@@ -18,6 +18,7 @@ class BMMinerAPI(BaseMinerAPI):
     :param ip: The IP of the miner to reference the API on.
     :param port: The port to reference the API on.  Default is 4028.
     """
+
     def __init__(self, ip: str, port: int = 4028) -> None:
         super().__init__(ip, port)
 
@@ -115,11 +116,7 @@ class BMMinerAPI(BaseMinerAPI):
         """
         return await self.send_command("enablepool", parameters=n)
 
-    async def addpool(self,
-                      url: str,
-                      username: str,
-                      password: str
-                      ) -> dict:
+    async def addpool(self, url: str, username: str, password: str) -> dict:
         """Add a pool to the miner.
 
         :param url: The URL of the new pool to add.
@@ -128,11 +125,9 @@ class BMMinerAPI(BaseMinerAPI):
 
         :return: A confirmation of adding the pool.
         """
-        return await self.send_command("addpool",
-                                       parameters=f"{url}, "
-                                                  f"{username}, "
-                                                  f"{password}"
-                                       )
+        return await self.send_command(
+            "addpool", parameters=f"{url}, " f"{username}, " f"{password}"
+        )
 
     async def poolpriority(self, *n: int) -> dict:
         """Set pool priority.
@@ -142,8 +137,7 @@ class BMMinerAPI(BaseMinerAPI):
         :return: A confirmation of setting pool priority.
         """
         pools = f"{','.join([str(item) for item in n])}"
-        return await self.send_command("poolpriority",
-                                       parameters=pools)
+        return await self.send_command("poolpriority", parameters=pools)
 
     async def poolquota(self, n: int, q: int) -> dict:
         """Set pool quota.
@@ -153,10 +147,7 @@ class BMMinerAPI(BaseMinerAPI):
 
         :return: A confirmation of setting pool quota.
         """
-        return await self.send_command("poolquota",
-                                       parameters=f"{n}, "
-                                                  f"{q}"
-                                       )
+        return await self.send_command("poolquota", parameters=f"{n}, " f"{q}")
 
     async def disablepool(self, n: int) -> dict:
         """Disable a pool.
@@ -292,9 +283,7 @@ class BMMinerAPI(BaseMinerAPI):
 
         :return: Confirmation of setting failover-only.
         """
-        return await self.send_command("failover-only",
-                                       parameters=failover
-                                       )
+        return await self.send_command("failover-only", parameters=failover)
 
     async def coin(self) -> dict:
         """Get information on the current coin.
@@ -337,10 +326,7 @@ class BMMinerAPI(BaseMinerAPI):
 
         :return: The results of setting config of name to n.
         """
-        return await self.send_command("setconfig",
-                                       parameters=f"{name}, "
-                                                  f"{n}"
-                                       )
+        return await self.send_command("setconfig", parameters=f"{name}, " f"{n}")
 
     async def usbstats(self) -> dict:
         """Get stats of all USB devices except ztex.
@@ -368,15 +354,11 @@ class BMMinerAPI(BaseMinerAPI):
         :return: Confirmation of setting PGA n with opt[,val].
         """
         if val:
-            return await self.send_command("pgaset",
-                                           parameters=f"{n}, "
-                                                      f"{opt}, "
-                                                      f"{val}"
-                                           )
+            return await self.send_command(
+                "pgaset", parameters=f"{n}, " f"{opt}, " f"{val}"
+            )
         else:
-            return await self.send_command("pgaset",
-                                           parameters=f"{n}, "
-                                                      f"{opt}")
+            return await self.send_command("pgaset", parameters=f"{n}, " f"{opt}")
 
     async def zero(self, which: str, summary: bool) -> dict:
         """Zero a device.

API/bosminer.py

@@ -2,64 +2,64 @@ from API import BaseMinerAPI
 
 
 class BOSMinerAPI(BaseMinerAPI):
-    """
-    A class that abstracts the BOSMiner API in the miners.
+    """An abstraction of the BOSMiner API.
 
     Each method corresponds to an API command in BOSMiner.
 
     BOSMiner API documentation:
         https://docs.braiins.com/os/plus-en/Development/1_api.html
 
-    Parameters:
-        ip: the IP address of the miner.
-        port (optional): the port of the API on the miner (standard is 4028)
+    This class abstracts use of the BOSMiner API, as well as the
+    methods for sending commands to it.  The self.send_command()
+    function handles sending a command to the miner asynchronously, and
+    as such is the base for many of the functions in this class, which
+    rely on it to send the command for them.
+
+    :param ip: The IP of the miner to reference the API on.
+    :param port: The port to reference the API on.  Default is 4028.
     """
+
     def __init__(self, ip, port=4028):
         super().__init__(ip, port)
 
     async def asccount(self) -> dict:
-        """
-        API 'asccount' command.
+        """Get data on the number of ASC devices and their info.
 
-        Returns a dict containing the number of ASC devices.
+        :return: Data on all ASC devices.
         """
         return await self.send_command("asccount")
 
     async def asc(self, n: int) -> dict:
-        """
-        API 'asc' command.
+        """Get data for ASC device n.
 
-        Returns a dict containing the details of a single ASC of number N.
+        :param n: The device to get data for.
 
-        n: the ASC device to get details of.
+        :return: The data for ASC device n.
         """
         return await self.send_command("asc", parameters=n)
 
     async def devdetails(self) -> dict:
-        """
-        API 'devdetails' command.
+        """Get data on all devices with their static details.
 
-        Returns a dict containing all devices with their static details.
+        :return: Data on all devices with their static details.
         """
         return await self.send_command("devdetails")
 
     async def devs(self) -> dict:
-        """
-        API 'devs' command.
+        """Get data on each PGA/ASC with their details.
 
-        Returns a dict containing each PGA/ASC with their details.
+        :return: Data on each PGA/ASC with their details.
         """
         return await self.send_command("devs")
 
     async def edevs(self, old: bool = False) -> dict:
-        """
-        API 'edevs' command.
+        """Get data on each PGA/ASC with their details, ignoring
+         blacklisted and zombie devices.
 
-        Returns a dict containing each PGA/ASC with their details,
-        ignoring blacklisted devices and zombie devices.
+        :param old: Include zombie devices that became zombies less
+        than 'old' seconds ago
 
-        Parameters:
-            old (optional): include zombie devices that became zombies less than 'old' seconds ago
+        :return: Data on each PGA/ASC with their details.
         """
         if old:
             return await self.send_command("edevs", parameters="old")
@@ -67,77 +67,76 @@ class BOSMinerAPI(BaseMinerAPI):
             return await self.send_command("edevs")
 
     async def pools(self) -> dict:
-        """
-        API 'pools' command.
+        """Get pool information.
 
-        Returns a dict containing the status of each pool.
+        :return: Miner pool information.
         """
         return await self.send_command("pools")
 
     async def summary(self) -> dict:
-        """
-        API 'summary' command.
+        """Get the status summary of the miner.
 
-        Returns a dict containing the status summary of the miner.
+        :return: The status summary of the miner.
         """
         return await self.send_command("summary")
 
     async def stats(self) -> dict:
-        """
-        API 'stats' command.
+        """Get stats of each device/pool with more than 1 getwork.
 
-        Returns a dict containing stats for all device/pool with more than 1 getwork.
+        :return: Stats of each device/pool with more than 1 getwork.
         """
         return await self.send_command("stats")
 
     async def version(self) -> dict:
-        """
-        API 'version' command.
+        """Get miner version info.
 
-        Returns a dict containing version information.
+        :return: Miner version information.
         """
         return await self.send_command("version")
 
-    async def estats(self) -> dict:
-        """
-        API 'estats' command.
+    async def estats(self, old: bool = False) -> dict:
+        """Get stats of each device/pool with more than 1 getwork,
+        ignoring zombie devices.
 
-        Returns a dict containing stats for all device/pool with more than 1 getwork,
+        :param old: Include zombie devices that became zombies less
+        than 'old' seconds ago.
+
+        :return: Stats of each device/pool with more than 1 getwork,
         ignoring zombie devices.
         """
-        return await self.send_command("estats")
+        if old:
+            return await self.send_command("estats", parameters=old)
+        else:
+            return await self.send_command("estats")
 
     async def check(self, command: str) -> dict:
-        """
-        API 'check' command.
+        """Check if the command command exists in BOSMiner.
 
-        Returns information about a command:
+        :param command: The command to check.
+
+        :return: Information about a command:
             Exists (Y/N) <- the command exists in this version
             Access (Y/N) <- you have access to use the command
-
-        Parameters:
-            command: the command to get information about.
         """
         return await self.send_command("check", parameters=command)
 
     async def coin(self) -> dict:
-        """
-        API 'coin' command.
+        """Get information on the current coin.
 
-        Returns information about the current coin being mined:
+        :return: Information about the current coin being mined:
             Hash Method <- the hashing algorithm
             Current Block Time <- blocktime as a float, 0 means none
-            Current Block Hash <- the hash of the current block, blank means none
+            Current Block Hash <- the hash of the current block, blank
+            means none
             LP <- whether LP is in use on at least 1 pool
             Network Difficulty: the current network difficulty
         """
         return await self.send_command("coin")
 
     async def lcd(self) -> dict:
-        """
-        API 'lcd' command.
+        """Get a general all-in-one status summary of the miner.
 
-        Returns a dict containing an all in one status summary of the miner.
+        :return: An all-in-one status summary of the miner.
         """
         return await self.send_command("lcd")
 
@@ -167,53 +166,43 @@ class BOSMinerAPI(BaseMinerAPI):
         # return await self.send_command("removepool", parameters=n)
 
     async def fans(self) -> dict:
-        """
-        API 'fans' command.
+        """Get fan data.
 
-        Returns a dict containing information on fans and fan speeds.
+        :return: Data on the fans of the miner.
         """
         return await self.send_command("fans")
 
     async def tempctrl(self) -> dict:
-        """
-        API 'tempctrl' command.
+        """Get temperature control data.
 
-        Returns a dict containing temp control configuration.
+        :return: Data about the temp control settings of the miner.
         """
         return await self.send_command("tempctrl")
 
     async def temps(self) -> dict:
-        """
-        API 'temps' command.
+        """Get temperature data.
 
-        Returns a dict containing temperature information.
+        :return: Data on the temps of the miner.
         """
         return await self.send_command("temps")
 
     async def tunerstatus(self) -> dict:
-        """
-        API 'tunerstatus' command.
+        """Get tuner status data
 
-        Returns a dict containing tuning stats.
+        :return: Data on the status of autotuning.
         """
         return await self.send_command("tunerstatus")
 
     async def pause(self) -> dict:
-        """
-        API 'pause' command.
+        """Pause mining.
 
-        Pauses mining and stops power consumption and waits for resume command.
-
-        Returns a dict stating that the miner paused mining.
+        :return: Confirmation of pausing mining.
         """
         return await self.send_command("pause")
 
     async def resume(self) -> dict:
-        """
-        API 'pause' command.
+        """Resume mining.
 
-        Resumes mining on the miner.
-
-        Returns a dict stating that the miner resumed mining.
+        :return: Confirmation of resuming mining.
         """
         return await self.send_command("resume")

API/btminer.py

@@ -4,16 +4,15 @@ import json
 import hashlib
 import binascii
 import base64
+import logging
 
 from passlib.handlers.md5_crypt import md5_crypt
-from cryptography.hazmat.primitives.ciphers import \
-    Cipher, algorithms, modes
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
 from API import BaseMinerAPI, APIError
 from settings import WHATSMINER_PWD
 
 
-
 ### IMPORTANT ###
 # you need to change the password of the miners using the Whatsminer
 # tool, then you can set them back to admin with this tool, but they
@@ -35,7 +34,7 @@ def _crypt(word: str, salt: str) -> str:
     :return: An MD5 hash of the word with the salt.
     """
     # compile a standard format for the salt
-    standard_salt = re.compile('\s*\$(\d+)\$([\w\./]*)\$')
+    standard_salt = re.compile("\s*\$(\d+)\$([\w\./]*)\$")
     # check if the salt matches
     match = standard_salt.match(salt)
     # if the matching fails, the salt is incorrect
@@ -58,7 +57,7 @@ def _add_to_16(string: str) -> bytes:
     length.
     """
     while len(string) % 16 != 0:
-        string += '\0'
+        string += "\0"
     return str.encode(string)  # return bytes
 
 
@@ -74,20 +73,20 @@ def parse_btminer_priviledge_data(token_data: dict, data: dict):
     :return: A decoded dict version of the privileged command output.
     """
     # get the encoded data from the dict
-    enc_data = data['enc']
+    enc_data = data["enc"]
     # get the aes key from the token data
-    aeskey = hashlib.sha256(
-        token_data['host_passwd_md5'].encode()
-    ).hexdigest()
+    aeskey = hashlib.sha256(token_data["host_passwd_md5"].encode()).hexdigest()
     # unhexlify the aes key
     aeskey = binascii.unhexlify(aeskey.encode())
     # create the required decryptor
     aes = Cipher(algorithms.AES(aeskey), modes.ECB())
     decryptor = aes.decryptor()
     # decode the message with the decryptor
-    ret_msg = json.loads(decryptor.update(
-        base64.decodebytes(bytes(enc_data, encoding='utf8'))
-    ).rstrip(b'\0').decode("utf8"))
+    ret_msg = json.loads(
+        decryptor.update(base64.decodebytes(bytes(enc_data, encoding="utf8")))
+        .rstrip(b"\0")
+        .decode("utf8")
+    )
     return ret_msg
 
 
@@ -104,11 +103,9 @@ def create_privileged_cmd(token_data: dict, command: dict) -> bytes:
     :return: The encrypted privileged command to be sent to the miner.
     """
     # add token to command
-    command['token'] = token_data['host_sign']
+    command["token"] = token_data["host_sign"]
     # encode host_passwd data and get hexdigest
-    aeskey = hashlib.sha256(
-        token_data['host_passwd_md5'].encode()
-    ).hexdigest()
+    aeskey = hashlib.sha256(token_data["host_passwd_md5"].encode()).hexdigest()
     # unhexlify the encoded host_passwd
     aeskey = binascii.unhexlify(aeskey.encode())
     # create a new AES key
@@ -117,18 +114,16 @@ def create_privileged_cmd(token_data: dict, command: dict) -> bytes:
     # dump the command to json
     api_json_str = json.dumps(command)
     # encode the json command with the aes key
-    api_json_str_enc = base64.encodebytes(
-        encryptor.update(
-            _add_to_16(
-                api_json_str
-            )
-        )
-    ).decode("utf-8").replace("\n", "")
+    api_json_str_enc = (
+        base64.encodebytes(encryptor.update(_add_to_16(api_json_str)))
+        .decode("utf-8")
+        .replace("\n", "")
+    )
     # label the data as being encoded
-    data_enc = {'enc': 1, 'data': api_json_str_enc}
+    data_enc = {"enc": 1, "data": api_json_str_enc}
     # dump the labeled data to json
     api_packet_str = json.dumps(data_enc)
-    return api_packet_str.encode('utf-8')
+    return api_packet_str.encode("utf-8")
 
 
 class BTMinerAPI(BaseMinerAPI):
@@ -157,16 +152,18 @@ class BTMinerAPI(BaseMinerAPI):
     :param port: The port to reference the API on.  Default is 4028.
     :param pwd: The admin password of the miner.  Default is admin.
     """
+
     def __init__(self, ip, port=4028, pwd: str = WHATSMINER_PWD):
         super().__init__(ip, port)
         self.admin_pwd = pwd
         self.current_token = None
 
-    async def send_command(self,
-                           command: str | bytes,
-                           parameters: str or int or bool = None,
-                           ignore_errors: bool = False
-                           ) -> dict:
+    async def send_command(
+        self,
+        command: str or bytes,
+        parameters: str or int or bool = None,
+        ignore_errors: bool = False,
+    ) -> dict:
         """Send a command to the miner API.
 
         Send a command using an asynchronous connection, load the data,
@@ -187,10 +184,7 @@ class BTMinerAPI(BaseMinerAPI):
             command = json.dumps({"command": command}).encode("utf-8")
         try:
             # get reader and writer streams
-            reader, writer = await asyncio.open_connection(
-                str(self.ip),
-                self.port
-            )
+            reader, writer = await asyncio.open_connection(str(self.ip), self.port)
         # handle OSError 121
         except OSError as e:
             if e.winerror == "121":
@@ -212,7 +206,7 @@ class BTMinerAPI(BaseMinerAPI):
                     break
                 data += d
         except Exception as e:
-            print(e)
+            logging.info(f"{str(self.ip)}: {e}")
 
         data = self.load_api_data(data)
 
@@ -221,15 +215,12 @@ class BTMinerAPI(BaseMinerAPI):
         await writer.wait_closed()
 
         # check if the returned data is encoded
-        if 'enc' in data.keys():
+        if "enc" in data.keys():
             # try to parse the encoded data
             try:
-                data = parse_btminer_priviledge_data(
-                    self.current_token,
-                    data
-                )
+                data = parse_btminer_priviledge_data(self.current_token, data)
             except Exception as e:
-                print(e)
+                logging.info(f"{str(self.ip)}: {e}")
 
         if not ignore_errors:
             # if it fails to validate, it is likely an error
@@ -250,25 +241,24 @@ class BTMinerAPI(BaseMinerAPI):
         data = await self.send_command("get_token")
 
         # encrypt the admin password with the salt
-        pwd = _crypt(self.admin_pwd, "$1$" + data["Msg"]["salt"] + '$')
-        pwd = pwd.split('$')
+        pwd = _crypt(self.admin_pwd, "$1$" + data["Msg"]["salt"] + "$")
+        pwd = pwd.split("$")
 
         # take the 4th item from the pwd split
         host_passwd_md5 = pwd[3]
 
         # encrypt the pwd with the time and new salt
-        tmp = _crypt(pwd[3] + data["Msg"]["time"],
-                     "$1$" + data["Msg"]["newsalt"] + '$'
-                     )
-        tmp = tmp.split('$')
+        tmp = _crypt(pwd[3] + data["Msg"]["time"], "$1$" + data["Msg"]["newsalt"] + "$")
+        tmp = tmp.split("$")
 
         # take the 4th item from the encrypted pwd split
         host_sign = tmp[3]
 
         # set the current token
-        self.current_token = {'host_sign': host_sign,
-                              'host_passwd_md5': host_passwd_md5
-                              }
+        self.current_token = {
+            "host_sign": host_sign,
+            "host_passwd_md5": host_passwd_md5,
+        }
         return self.current_token
 
     #### PRIVILEGED COMMANDS ####
@@ -276,19 +266,18 @@ class BTMinerAPI(BaseMinerAPI):
     # how to configure the Whatsminer API to
     # use these commands.
 
-    async def update_pools(self,
-                           pool_1: str,
-                           worker_1: str,
-                           passwd_1: str,
-
-                           pool_2: str = None,
-                           worker_2: str = None,
-                           passwd_2: str = None,
-
-                           pool_3: str = None,
-                           worker_3: str = None,
-                           passwd_3: str = None
-                           ):
+    async def update_pools(
+        self,
+        pool_1: str,
+        worker_1: str,
+        passwd_1: str,
+        pool_2: str = None,
+        worker_2: str = None,
+        passwd_2: str = None,
+        pool_3: str = None,
+        worker_3: str = None,
+        passwd_3: str = None,
+    ):
         """Update the pools of the miner using the API.
 
         Update the pools of the miner using the API, only works after
@@ -314,15 +303,12 @@ class BTMinerAPI(BaseMinerAPI):
         elif pool_2 and pool_3:
             command = {
                 "cmd": "update_pools",
-
                 "pool1": pool_1,
                 "worker1": worker_1,
                 "passwd1": passwd_1,
-
                 "pool2": pool_2,
                 "worker2": worker_2,
                 "passwd2": passwd_2,
-
                 "pool3": pool_3,
                 "worker3": worker_3,
                 "passwd3": passwd_3,
@@ -333,10 +319,9 @@ class BTMinerAPI(BaseMinerAPI):
                 "pool1": pool_1,
                 "worker1": worker_1,
                 "passwd1": passwd_1,
-
                 "pool2": pool_2,
                 "worker2": worker_2,
-                "passwd2": passwd_2
+                "passwd2": passwd_2,
             }
         else:
             command = {
@@ -406,12 +391,13 @@ class BTMinerAPI(BaseMinerAPI):
         enc_command = create_privileged_cmd(token_data, command)
         return await self.send_command(enc_command)
 
-    async def set_led(self,
-                      color: str = "red",
-                      period: int = 2000,
-                      duration: int = 1000,
-                      start: int = 0
-                      ):
+    async def set_led(
+        self,
+        color: str = "red",
+        period: int = 2000,
+        duration: int = 1000,
+        start: int = 0,
+    ):
         """Set the LED on the miner using the API.
 
         Set the LED on the miner using the API, only works after
@@ -423,12 +409,13 @@ class BTMinerAPI(BaseMinerAPI):
         :param start: LED on time offset in the cycle in ms.
         :return: A reply informing of the status of setting the LED.
         """
-        command = {"cmd": "set_led",
-                   "color": color,
-                   "period": period,
-                   "duration": duration,
-                   "start": start
-                   }
+        command = {
+            "cmd": "set_led",
+            "color": color,
+            "period": period,
+            "duration": duration,
+            "start": start,
+        }
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
         return await self.send_command(enc_command)
@@ -486,10 +473,11 @@ class BTMinerAPI(BaseMinerAPI):
         password.
         """
         # check if password length is greater than 8 bytes
-        if len(new_pwd.encode('utf-8')) > 8:
+        if len(new_pwd.encode("utf-8")) > 8:
             return APIError(
                 f"New password too long, the max length is 8.  "
-                f"Password size: {len(new_pwd.encode('utf-8'))}")
+                f"Password size: {len(new_pwd.encode('utf-8'))}"
+            )
         command = {"cmd": "update_pwd", "old": old_pwd, "new": new_pwd}
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
@@ -507,9 +495,11 @@ class BTMinerAPI(BaseMinerAPI):
         frequency.
         """
         if not -10 < percent < 100:
-            return APIError(f"Frequency % is outside of the allowed "
-                            f"range.  Please set a % between -10 and "
-                            f"100")
+            return APIError(
+                f"Frequency % is outside of the allowed "
+                f"range.  Please set a % between -10 and "
+                f"100"
+            )
         command = {"cmd": "set_target_freq", "percent": str(percent)}
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
@@ -596,9 +586,11 @@ class BTMinerAPI(BaseMinerAPI):
         """
 
         if not 0 < percent < 100:
-            return APIError(f"Power PCT % is outside of the allowed "
-                            f"range.  Please set a % between 0 and "
-                            f"100")
+            return APIError(
+                f"Power PCT % is outside of the allowed "
+                f"range.  Please set a % between 0 and "
+                f"100"
+            )
         command = {"cmd": "set_power_pct", "percent": str(percent)}
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
@@ -618,12 +610,9 @@ class BTMinerAPI(BaseMinerAPI):
         :return: A reply informing of the status of pre power on.
         """
 
-        if not msg == \
-                "wait for adjust temp" or \
-                "adjust complete" or \
-                "adjust continue":
+        if not msg == "wait for adjust temp" or "adjust complete" or "adjust continue":
             return APIError(
-                'Message is incorrect, please choose one of '
+                "Message is incorrect, please choose one of "
                 '["wait for adjust temp", '
                 '"adjust complete", '
                 '"adjust continue"]'
@@ -632,10 +621,7 @@ class BTMinerAPI(BaseMinerAPI):
             complete = "true"
         else:
             complete = "false"
-        command = {"cmd": "pre_power_on",
-                   "complete": complete,
-                   "msg": msg
-                   }
+        command = {"cmd": "pre_power_on", "complete": complete, "msg": msg}
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
         return await self.send_command(enc_command)

API/cgminer.py

@@ -2,14 +2,14 @@ from API import BaseMinerAPI
 
 
 class CGMinerAPI(BaseMinerAPI):
-    """An abstraction of the BMMiner API.
+    """An abstraction of the CGMiner API.
 
-    Each method corresponds to an API command in BMMiner.
+    Each method corresponds to an API command in GGMiner.
 
     CGMiner API documentation:
         https://github.com/ckolivas/cgminer/blob/master/API-README
 
-    This class abstracts use of the BMMiner API, as well as the
+    This class abstracts use of the CGMiner API, as well as the
     methods for sending commands to it.  The self.send_command()
     function handles sending a command to the miner asynchronously, and
     as such is the base for many of the functions in this class, which
@@ -18,6 +18,7 @@ class CGMinerAPI(BaseMinerAPI):
     :param ip: The IP of the miner to reference the API on.
     :param port: The port to reference the API on.  Default is 4028.
     """
+
     def __init__(self, ip, port=4028):
         super().__init__(ip, port)
 
@@ -111,11 +112,7 @@ class CGMinerAPI(BaseMinerAPI):
         """
         return await self.send_command("enablepool", parameters=n)
 
-    async def addpool(self,
-                      url: str,
-                      username: str,
-                      password: str
-                      ) -> dict:
+    async def addpool(self, url: str, username: str, password: str) -> dict:
         """Add a pool to the miner.
 
         :param url: The URL of the new pool to add.
@@ -124,11 +121,9 @@ class CGMinerAPI(BaseMinerAPI):
 
         :return: A confirmation of adding the pool.
         """
-        return await self.send_command("addpool",
-                                       parameters=f"{url}, "
-                                                  f"{username}, "
-                                                  f"{password}"
-                                       )
+        return await self.send_command(
+            "addpool", parameters=f"{url}, " f"{username}, " f"{password}"
+        )
 
     async def poolpriority(self, *n: int) -> dict:
         """Set pool priority.
@@ -138,8 +133,7 @@ class CGMinerAPI(BaseMinerAPI):
         :return: A confirmation of setting pool priority.
         """
         pools = f"{','.join([str(item) for item in n])}"
-        return await self.send_command("poolpriority",
-                                       parameters=pools)
+        return await self.send_command("poolpriority", parameters=pools)
 
     async def poolquota(self, n: int, q: int) -> dict:
         """Set pool quota.
@@ -149,10 +143,7 @@ class CGMinerAPI(BaseMinerAPI):
 
         :return: A confirmation of setting pool quota.
         """
-        return await self.send_command("poolquota",
-                                       parameters=f"{n}, "
-                                                  f"{q}"
-                                       )
+        return await self.send_command("poolquota", parameters=f"{n}, " f"{q}")
 
     async def disablepool(self, n: int) -> dict:
         """Disable a pool.
@@ -185,7 +176,7 @@ class CGMinerAPI(BaseMinerAPI):
             return await self.send_command("save")
 
     async def quit(self) -> dict:
-        """Quit BMMiner.
+        """Quit CGMiner.
 
         :return: A single "BYE" before CGMiner quits.
         """
@@ -270,7 +261,7 @@ class CGMinerAPI(BaseMinerAPI):
             return await self.send_command("estats")
 
     async def check(self, command: str) -> dict:
-        """Check if the command command exists in BMMiner.
+        """Check if the command command exists in CGMiner.
 
         :param command: The command to check.
 
@@ -288,9 +279,7 @@ class CGMinerAPI(BaseMinerAPI):
 
         :return: Confirmation of setting failover-only.
         """
-        return await self.send_command("failover-only",
-                                       parameters=failover
-                                       )
+        return await self.send_command("failover-only", parameters=failover)
 
     async def coin(self) -> dict:
         """Get information on the current coin.
@@ -333,10 +322,7 @@ class CGMinerAPI(BaseMinerAPI):
 
         :return: The results of setting config of name to n.
         """
-        return await self.send_command("setconfig",
-                                       parameters=f"{name}, "
-                                                  f"{n}"
-                                       )
+        return await self.send_command("setconfig", parameters=f"{name}, " f"{n}")
 
     async def usbstats(self) -> dict:
         """Get stats of all USB devices except ztex.
@@ -364,9 +350,11 @@ class CGMinerAPI(BaseMinerAPI):
         :return: Confirmation of setting PGA n with opt[,val].
         """
         if val:
-            return await self.send_command("pgaset", parameters=f"{n}, {opt}, {val}")
+            return await self.send_command(
+                "pgaset", parameters=f"{n}, " f"{opt}, " f"{val}"
+            )
         else:
-            return await self.send_command("pgaset", parameters=f"{n}, {opt}")
+            return await self.send_command("pgaset", parameters=f"{n}, " f"{opt}")
 
     async def zero(self, which: str, summary: bool) -> dict:
         """Zero a device.
@@ -381,7 +369,7 @@ class CGMinerAPI(BaseMinerAPI):
         :return: the STATUS section with info on the zero and optional
         summary.
         """
-        return await self.send_command("zero", parameters=f"{which}, {summary}")
+        return await self.send_command("zero", parameters=f"{which}, " f"{summary}")
 
     async def hotplug(self, n: int) -> dict:
         """Enable hotplug.
@@ -482,9 +470,11 @@ class CGMinerAPI(BaseMinerAPI):
         :return: Confirmation of setting option opt to value val.
         """
         if val:
-            return await self.send_command("ascset", parameters=f"{n}, {opt}, {val}")
+            return await self.send_command(
+                "ascset", parameters=f"{n}, " f"{opt}, " f"{val}"
+            )
         else:
-            return await self.send_command("ascset", parameters=f"{n}, {opt}")
+            return await self.send_command("ascset", parameters=f"{n}, " f"{opt}")
 
     async def lcd(self) -> dict:
         """Get a general all-in-one status summary of the miner.

API/unknown.py

@@ -2,6 +2,13 @@ from API import BaseMinerAPI
 
 
 class UnknownAPI(BaseMinerAPI):
+    """An abstraction of an API for a miner which is unknown.
+
+    This class is designed to try to be a intersection of as many miner APIs
+    and API commands as possible (API ⋂ API), to ensure that it can be used
+    with as many APIs as possible.
+    """
+
     def __init__(self, ip, port=4028):
         super().__init__(ip, port)
 

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10-slim-buster
+
+EXPOSE 80
+
+WORKDIR /minerInterface-web_monitor
+
+COPY tools/web_monitor/requirements.txt .
+
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "tools.web_monitor.app:app", "--host", "0.0.0.0", "--port", "80"]

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.
 
@@ -48,7 +48,7 @@ A basic script to find all miners on the network and get the hashrate from them
 ```python
 import asyncio
 from network import MinerNetwork
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from tools.cfg_util_old.func.parse_data import safe_parse_api_data
 
 
 async def get_hashrate():
@@ -84,7 +84,7 @@ You can also create your own miner without scanning if you know the IP:
 import asyncio
 import ipaddress
 from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from tools.cfg_util_old.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_hashrate(ip: str):
@@ -103,69 +103,48 @@ async def get_miner_hashrate(ip: str):
 
 
 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.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.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")))
+    asyncio.new_event_loop().run_until_complete(
+        get_miner_hashrate(str("192.168.1.69")))
 ```
 
 
 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.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_pool_data(ip: str):
@@ -179,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
@@ -189,7 +168,8 @@ async def get_miner_pool_data(ip: str):
 
 
 if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_pool_data(str("192.168.1.69")))
+    asyncio.new_event_loop().run_until_complete(
+        get_miner_pool_data(str("192.168.1.69")))
 ```
 
 * Getting temperature data:
@@ -204,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.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_temperature_data(ip: str):
@@ -216,14 +195,14 @@ 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)
 
 
 if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_temperature_data(str("192.168.1.69")))
+    asyncio.new_event_loop().run_until_complete(
+        get_miner_temperature_data(str("192.168.1.69")))
 ```
 
 * Getting power data:
@@ -234,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.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
@@ -249,19 +228,21 @@ 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__':
-    asyncio.new_event_loop().run_until_complete(get_miner_power_data(str("192.168.1.69")))
+    asyncio.new_event_loop().run_until_complete(
+        get_miner_power_data(str("192.168.1.69")))
 ```
 
 * Multicommands:
@@ -273,7 +254,7 @@ How about we get the current pool user and hashrate in 1 command?
 import asyncio
 import ipaddress
 from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from tools.cfg_util_old.func.parse_data import safe_parse_api_data
 
 
 async def get_miner_hashrate_and_pool(ip: str):
@@ -286,15 +267,14 @@ 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)
 
 
 if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_hashrate_and_pool(str("192.168.1.9")))
+    asyncio.new_event_loop().run_until_complete(
+        get_miner_hashrate_and_pool(str("192.168.1.9")))
 ```
-
-

board_util.py

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

config/bos.py

@@ -3,12 +3,12 @@ import yaml
 import toml
 
 
-async def bos_config_convert(config: dict):
+def bos_config_convert(config: dict):
     out_config = {}
     for opt in config:
         if opt == "format":
             out_config["format"] = config[opt]
-            out_config["format"]["generator"] = 'upstream_config_util'
+            out_config["format"]["generator"] = "upstream_config_util"
             out_config["format"]["timestamp"] = int(time.time())
         elif opt == "temp_control":
             out_config["temperature"] = {}
@@ -47,20 +47,28 @@ async def bos_config_convert(config: dict):
                 out_config["pool_groups"][idx]["pools"] = []
                 out_config["pool_groups"][idx] = {}
                 if "name" in config[opt][idx].keys():
-                    out_config["pool_groups"][idx]["group_name"] = config[opt][idx]["name"]
+                    out_config["pool_groups"][idx]["group_name"] = config[opt][idx][
+                        "name"
+                    ]
                 else:
                     out_config["pool_groups"][idx]["group_name"] = f"group_{idx}"
                 if "quota" in config[opt][idx].keys():
                     out_config["pool_groups"][idx]["quota"] = config[opt][idx]["quota"]
                 else:
                     out_config["pool_groups"][idx]["quota"] = 1
-                out_config["pool_groups"][idx]["pools"] = [{} for _item in range(len(config[opt][idx]["pool"]))]
+                out_config["pool_groups"][idx]["pools"] = [
+                    {} for _item in range(len(config[opt][idx]["pool"]))
+                ]
                 for pool_idx in range(len(config[opt][idx]["pool"])):
-                    out_config["pool_groups"][idx]["pools"][pool_idx]["url"] = config[opt][idx]["pool"][pool_idx]["url"]
-                    out_config["pool_groups"][idx]["pools"][pool_idx]["username"] = config[opt][idx]["pool"][pool_idx][
-                        "user"]
-                    out_config["pool_groups"][idx]["pools"][pool_idx]["password"] = config[opt][idx]["pool"][pool_idx][
-                        "password"]
+                    out_config["pool_groups"][idx]["pools"][pool_idx]["url"] = config[
+                        opt
+                    ][idx]["pool"][pool_idx]["url"]
+                    out_config["pool_groups"][idx]["pools"][pool_idx][
+                        "username"
+                    ] = config[opt][idx]["pool"][pool_idx]["user"]
+                    out_config["pool_groups"][idx]["pools"][pool_idx][
+                        "password"
+                    ] = config[opt][idx]["pool"][pool_idx]["password"]
         elif opt == "autotuning":
             out_config["autotuning"] = {}
             if "enabled" in config[opt].keys():
@@ -82,27 +90,33 @@ async def bos_config_convert(config: dict):
             else:
                 out_config["power_scaling"]["power_step"] = 100
             if "min_psu_power_limit" in config[opt].keys():
-                out_config["power_scaling"]["min_psu_power_limit"] = config[opt]["min_psu_power_limit"]
+                out_config["power_scaling"]["min_psu_power_limit"] = config[opt][
+                    "min_psu_power_limit"
+                ]
             else:
                 out_config["power_scaling"]["min_psu_power_limit"] = 800
             if "shutdown_enabled" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_enabled"] = config[opt]["shutdown_enabled"]
+                out_config["power_scaling"]["shutdown_enabled"] = config[opt][
+                    "shutdown_enabled"
+                ]
             else:
                 out_config["power_scaling"]["shutdown_enabled"] = False
             if "shutdown_duration" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_duration"] = config[opt]["shutdown_duration"]
+                out_config["power_scaling"]["shutdown_duration"] = config[opt][
+                    "shutdown_duration"
+                ]
             else:
                 out_config["power_scaling"]["shutdown_duration"] = 3.0
     return yaml.dump(out_config, sort_keys=False)
 
 
-async def general_config_convert_bos(yaml_config):
+def general_config_convert_bos(yaml_config, user_suffix: str = None):
     config = yaml.load(yaml_config, Loader=yaml.SafeLoader)
     out_config = {}
     for opt in config:
         if opt == "format":
             out_config["format"] = config[opt]
-            out_config["format"]["generator"] = 'upstream_config_util'
+            out_config["format"]["generator"] = "upstream_config_util"
             out_config["format"]["timestamp"] = int(time.time())
         elif opt == "temperature":
             out_config["temp_control"] = {}
@@ -148,11 +162,24 @@ async def general_config_convert_bos(yaml_config):
                     out_config["group"][idx]["quota"] = config[opt][idx]["quota"]
                 else:
                     out_config["group"][idx]["quota"] = 1
-                out_config["group"][idx]["pool"] = [{} for _item in range(len(config[opt][idx]["pools"]))]
+                out_config["group"][idx]["pool"] = [
+                    {} for _item in range(len(config[opt][idx]["pools"]))
+                ]
                 for pool_idx in range(len(config[opt][idx]["pools"])):
-                    out_config["group"][idx]["pool"][pool_idx]["url"] = config[opt][idx]["pools"][pool_idx]["url"]
-                    out_config["group"][idx]["pool"][pool_idx]["user"] = config[opt][idx]["pools"][pool_idx]["username"]
-                    out_config["group"][idx]["pool"][pool_idx]["password"] = config[opt][idx]["pools"][pool_idx]["password"]
+                    out_config["group"][idx]["pool"][pool_idx]["url"] = config[opt][
+                        idx
+                    ]["pools"][pool_idx]["url"]
+                    username = config[opt][idx]["pools"][pool_idx]["username"]
+                    if user_suffix:
+                        if "." in username:
+                            username = f"{username}x{user_suffix}"
+                        else:
+                            username = f"{username}.{user_suffix}"
+                    out_config["group"][idx]["pool"][pool_idx]["user"] = username
+
+                    out_config["group"][idx]["pool"][pool_idx]["password"] = config[
+                        opt
+                    ][idx]["pools"][pool_idx]["password"]
         elif opt == "autotuning":
             out_config["autotuning"] = {}
             if "enabled" in config[opt].keys():
@@ -174,15 +201,21 @@ async def general_config_convert_bos(yaml_config):
             else:
                 out_config["power_scaling"]["power_step"] = 100
             if "min_psu_power_limit" in config[opt].keys():
-                out_config["power_scaling"]["min_psu_power_limit"] = config[opt]["min_psu_power_limit"]
+                out_config["power_scaling"]["min_psu_power_limit"] = config[opt][
+                    "min_psu_power_limit"
+                ]
             else:
                 out_config["power_scaling"]["min_psu_power_limit"] = 800
             if "shutdown_enabled" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_enabled"] = config[opt]["shutdown_enabled"]
+                out_config["power_scaling"]["shutdown_enabled"] = config[opt][
+                    "shutdown_enabled"
+                ]
             else:
                 out_config["power_scaling"]["shutdown_enabled"] = False
             if "shutdown_duration" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_duration"] = config[opt]["shutdown_duration"]
+                out_config["power_scaling"]["shutdown_duration"] = config[opt][
+                    "shutdown_duration"
+                ]
             else:
                 out_config["power_scaling"]["shutdown_duration"] = 3.0
-    return toml.dumps(out_config)
+    return out_config

config_tool.py

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

logger/__init__.py

@@ -0,0 +1,18 @@
+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()
+
+if DEBUG:
+    logger.setLevel(logging.DEBUG)
+    logging.getLogger("asyncssh").setLevel(logging.DEBUG)
+else:
+    logger.setLevel(logging.INFO)
+    logging.getLogger("asyncssh").setLevel(logging.WARNING)

make_board_tool_exe.py

@@ -1,29 +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}\\"
-                             },
-               },
-      executables=[Executable("board_util.py", base=base, icon="icon.ico", target_name="UpstreamBoardUtil.exe")]
-      )

make_cfg_tool_exe.py

@@ -19,13 +19,25 @@ version = version.strftime("%y.%m.%d")
 print(version)
 
 
-setup(name="UpstreamCFGUtil.exe",
-      version=version,
-      description="Upstream Data Config Utility Build",
-      options={"build_exe": {"build_exe": f"{os.getcwd()}\\build\\UpstreamCFGUtil-{version}-{sys.platform}\\",
-                             "include_files": [os.path.join(os.getcwd(), "settings/settings.toml"),
-                                               os.path.join(os.getcwd(), "static/CFG-Util-README.md")],
-                             },
-               },
-      executables=[Executable("config_tool.py", base=base, icon="icon.ico", target_name="UpstreamCFGUtil.exe")]
-      )
+setup(
+    name="UpstreamCFGUtil.exe",
+    version=version,
+    description="Upstream Data Config Utility Build",
+    options={
+        "build_exe": {
+            "build_exe": f"{os.getcwd()}\\build\\UpstreamCFGUtil-{version}-{sys.platform}\\",
+            "include_files": [
+                os.path.join(os.getcwd(), "settings/settings.toml"),
+                os.path.join(os.getcwd(), "static/CFG-Util-README.md"),
+            ],
+        },
+    },
+    executables=[
+        Executable(
+            "config_tool.py",
+            base=base,
+            icon="icon.ico",
+            target_name="UpstreamCFGUtil.exe",
+        )
+    ],
+)

miners/__init__.py

@@ -1,17 +1,66 @@
-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
 
 
 class BaseMiner:
-    def __init__(self, ip: str, api: BMMinerAPI | BOSMinerAPI | CGMinerAPI | BTMinerAPI | UnknownAPI) -> None:
-        self.ip = ipaddress.ip_address(ip)
-        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
+
+    def __repr__(self):
+        return f"{'' if not self.api_type else self.api_type} {'' if not self.model else self.model}: {str(self.ip)}"
+
+    async def _get_ssh_connection(self) -> asyncssh.connect:
+        """Create a new asyncssh connection"""
+        try:
+            conn = await asyncssh.connect(
+                str(self.ip),
+                known_hosts=None,
+                username=self.uname,
+                password=self.pwd,
+                server_host_key_algs=["ssh-rsa"],
+            )
+            return conn
+        except asyncssh.misc.PermissionDenied:
+            try:
+                conn = await asyncssh.connect(
+                    str(self.ip),
+                    known_hosts=None,
+                    username="root",
+                    password="admin",
+                    server_host_key_algs=["ssh-rsa"],
+                )
+                return conn
+            except Exception as e:
+                # logging.warning(f"{self} raised an exception: {e}")
+                raise e
+        except OSError as e:
+            logging.warning(f"Connection refused: {self}")
+            raise e
+        except Exception as e:
+            # logging.warning(f"{self} raised an exception: {e}")
+            raise e
+
+    async def fault_light_on(self) -> bool:
+        return False
+
+    async def fault_light_off(self) -> bool:
+        return False
+
+    async def send_file(self, src, dest):
+        async with (await self._get_ssh_connection()) as conn:
+            await asyncssh.scp(src, (conn, dest))
+
+    async def check_light(self):
+        return self.light
 
     async def get_board_info(self):
         return None
@@ -26,14 +75,30 @@ class BaseMiner:
         return None
 
     async def reboot(self):
-        return None
+        return False
 
     async def restart_backend(self):
+        return False
+
+    async def send_config(self, *args, **kwargs):
         return None
 
-    async def send_config(self, yaml_config):
+    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

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

@@ -0,0 +1,246 @@
+from API.bmminer import BMMinerAPI
+from miners import BaseMiner
+import logging
+from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
+
+
+class BMMiner(BaseMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+        self.api = BMMinerAPI(ip)
+        self.api_type = "BMMiner"
+        self.uname = "root"
+        self.pwd = "admin"
+
+    async def get_model(self) -> str or None:
+        """Get miner model.
+
+        :return: Miner model or None.
+        """
+        # check if model is cached
+        if self.model:
+            logging.debug(f"Found model for {self.ip}: {self.model}")
+            return self.model
+
+        # get devdetails data
+        version_data = await self.api.devdetails()
+
+        # if we get data back, parse it for model
+        if version_data:
+            # handle Antminer BMMiner as a base
+            self.model = version_data["DEVDETAILS"][0]["Model"].replace("Antminer ", "")
+            logging.debug(f"Found model for {self.ip}: {self.model}")
+            return self.model
+
+        # if we don't get devdetails, log a failed attempt
+        logging.warning(f"Failed to get model for miner: {self}")
+        return None
+
+    async def get_hostname(self) -> str:
+        """Get miner hostname.
+
+        :return: The hostname of the miner as a string or "?"
+        """
+        if self.hostname:
+            return self.hostname
+        try:
+            # open an ssh connection
+            async with (await self._get_ssh_connection()) as conn:
+                # if we get the connection, check hostname
+                if conn is not None:
+                    # get output of the hostname file
+                    data = await conn.run("cat /proc/sys/kernel/hostname")
+                    host = data.stdout.strip()
+
+                    # return hostname data
+                    logging.debug(f"Found hostname for {self.ip}: {host}")
+                    self.hostname = host
+                    return self.hostname
+                else:
+                    # 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:
+            # return ? if we fail to get hostname with an exception
+            logging.warning(f"Failed to get hostname for miner: {self}")
+            return "?"
+
+    async def send_ssh_command(self, cmd: str) -> str or None:
+        """Send a command to the miner over ssh.
+
+        :param cmd: The command to run.
+
+        :return: Result of the command or None.
+        """
+        result = None
+
+        # open an ssh connection
+        async with (await self._get_ssh_connection()) 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 result
+
+    async def get_config(self) -> list or None:
+        """Get the pool configuration of the miner.
+
+        :return: Pool config data or None.
+        """
+        # get pool data
+        pools = await self.api.pools()
+        pool_data = []
+
+        # ensure we got pool data
+        if not pools:
+            return
+
+        # parse all the pools
+        for pool in pools["POOLS"]:
+            pool_data.append({"url": pool["URL"], "user": pool["User"], "pwd": "123"})
+        return pool_data
+
+    async def reboot(self) -> bool:
+        logging.debug(f"{self}: Sending reboot command.")
+        _ret = await self.send_ssh_command("reboot")
+        logging.debug(f"{self}: Reboot command completed.")
+        if isinstance(_ret, str):
+            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,
+            "Total": 0,
+            "Ideal": self.nominal_chips * 3,
+            "Left Board": 0,
+            "Center Board": 0,
+            "Right Board": 0,
+            "Nominal": False,
+            "Split": "0",
+            "Pool 1": "Unknown",
+            "Pool 1 User": "Unknown",
+            "Pool 2": "",
+            "Pool 2 User": "",
+        }
+
+        model = await self.get_model()
+        hostname = await self.get_hostname()
+
+        if model:
+            data["Model"] = model
+
+        if hostname:
+            data["Hostname"] = hostname
+
+        miner_data = None
+        for i in range(DATA_RETRIES):
+            miner_data = await self.api.multicommand("summary", "pools", "stats")
+            if miner_data:
+                break
+
+        if not miner_data:
+            return data
+
+        summary = miner_data.get("summary")[0]
+        pools = miner_data.get("pools")[0]
+        stats = miner_data.get("stats")[0]
+
+        if summary:
+            hr = summary.get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("GHS av")
+                    if hr:
+                        data["Hashrate"] = round(hr / 1000, 2)
+
+        if stats:
+            boards = stats.get("STATS")
+            if boards:
+                if len(boards) > 0:
+                    data["Left Board"] = boards[1].get("chain_acn1")
+                    data["Center Board"] = boards[1].get("chain_acn2")
+                    data["Right Board"] = boards[1].get("chain_acn3")
+                    data["Total"] = boards[1].get("total_acn")
+
+        if data["Total"] == data["Ideal"]:
+            data["Nominal"] = True
+
+        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)
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools.get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                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
+
+            if pool_1_user:
+                data["Pool 1 User"] = pool_1_user
+                data["Pool 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
+
+            if pool_2_user:
+                data["Pool 2 User"] = pool_2_user
+
+            if quota:
+                data["Split"] = str(quota)
+
+        return data

miners/_backends/bosminer.py

@@ -0,0 +1,375 @@
+from miners import BaseMiner
+from API.bosminer import BOSMinerAPI
+import toml
+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:
+        super().__init__(ip)
+        self.ip = 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 self._get_ssh_connection()) 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 fault_light_on(self) -> bool:
+        """Sends command to turn on fault light on the miner."""
+        logging.debug(f"{self}: Sending fault_light on command.")
+        self.light = True
+        _ret = await self.send_ssh_command("miner fault_light on")
+        logging.debug(f"{self}: fault_light on command completed.")
+        if isinstance(_ret, str):
+            return True
+        return False
+
+    async def fault_light_off(self) -> bool:
+        """Sends command to turn off fault light on the miner."""
+        logging.debug(f"{self}: Sending fault_light off command.")
+        self.light = False
+        _ret = await self.send_ssh_command("miner fault_light off")
+        logging.debug(f"{self}: fault_light off command completed.")
+        if isinstance(_ret, str):
+            return True
+        return False
+
+    async def restart_backend(self) -> bool:
+        return await self.restart_bosminer()
+
+    async def restart_bosminer(self) -> bool:
+        """Restart bosminer hashing process."""
+        logging.debug(f"{self}: Sending bosminer restart command.")
+        _ret = await self.send_ssh_command("/etc/init.d/bosminer restart")
+        logging.debug(f"{self}: bosminer restart command completed.")
+        if isinstance(_ret, str):
+            return True
+        return False
+
+    async def reboot(self) -> bool:
+        """Reboots power to the physical miner."""
+        logging.debug(f"{self}: Sending reboot command.")
+        _ret = await self.send_ssh_command("/sbin/reboot")
+        logging.debug(f"{self}: Reboot command completed.")
+        if isinstance(_ret, str):
+            return True
+        return False
+
+    async def get_config(self) -> None:
+        logging.debug(f"{self}: Getting config.")
+        async with (await self._get_ssh_connection()) as conn:
+            logging.debug(f"{self}: Opening SFTP connection.")
+            async with conn.start_sftp_client() as sftp:
+                logging.debug(f"{self}: Reading config file.")
+                async with sftp.open("/etc/bosminer.toml") as file:
+                    toml_data = toml.loads(await file.read())
+        logging.debug(f"{self}: Converting config file.")
+        cfg = bos_config_convert(toml_data)
+        self.config = cfg
+
+    async def get_hostname(self) -> str:
+        """Get miner hostname.
+
+        :return: The hostname of the miner as a string or "?"
+        """
+        if self.hostname:
+            return self.hostname
+        try:
+            async with (await self._get_ssh_connection()) as conn:
+                if conn is not None:
+                    data = await conn.run("cat /proc/sys/kernel/hostname")
+                    host = data.stdout.strip()
+                    logging.debug(f"Found hostname for {self.ip}: {host}")
+                    self.hostname = host
+                    return self.hostname
+                else:
+                    logging.warning(f"Failed to get hostname for miner: {self}")
+                    return "?"
+        except Exception as e:
+            logging.warning(f"Failed to get hostname for miner: {self}")
+            return "?"
+
+    async def get_model(self) -> str or None:
+        """Get miner model.
+
+        :return: Miner model or None.
+        """
+        # check if model is cached
+        if self.model:
+            logging.debug(f"Found model for {self.ip}: {self.model} (BOS)")
+            return self.model + " (BOS)"
+
+        # get devdetails data
+        version_data = await self.api.devdetails()
+
+        # if we get data back, parse it for model
+        if version_data:
+            if not version_data["DEVDETAILS"] == []:
+                # handle Antminer BOSMiner as a base
+                self.model = version_data["DEVDETAILS"][0]["Model"].replace(
+                    "Antminer ", ""
+                )
+                logging.debug(f"Found model for {self.ip}: {self.model} (BOS)")
+                return self.model + " (BOS)"
+
+        # if we don't get devdetails, log a failed attempt
+        logging.warning(f"Failed to get model for miner: {self}")
+        return None
+
+    async def get_version(self):
+        """Get miner firmware version.
+
+        :return: Miner firmware version or None.
+        """
+        # check if version is cached
+        if self.version:
+            logging.debug(f"Found version for {self.ip}: {self.version}")
+            return self.version
+
+        # get output of bos version file
+        version_data = await self.send_ssh_command("cat /etc/bos_version")
+
+        # if we get the version data, parse it
+        if version_data:
+            self.version = version_data.stdout.split("-")[5]
+            logging.debug(f"Found version for {self.ip}: {self.version}")
+            return self.version
+
+        # if we fail to get version, log a failed attempt
+        logging.warning(f"Failed to get model for miner: {self}")
+        return None
+
+    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
+        """Configures miner with yaml config."""
+        logging.debug(f"{self}: Sending config.")
+        if ip_user:
+            suffix = str(self.ip).split(".")[-1]
+            toml_conf = toml.dumps(
+                general_config_convert_bos(yaml_config, user_suffix=suffix)
+            )
+        else:
+            toml_conf = toml.dumps(general_config_convert_bos(yaml_config))
+        async with (await self._get_ssh_connection()) as conn:
+            logging.debug(f"{self}: Opening SFTP connection.")
+            async with conn.start_sftp_client() as sftp:
+                logging.debug(f"{self}: Opening config file.")
+                async with sftp.open("/etc/bosminer.toml", "w+") as file:
+                    await file.write(toml_conf)
+            logging.debug(f"{self}: Restarting BOSMiner")
+            await conn.run("/etc/init.d/bosminer restart")
+
+    async def get_board_info(self) -> dict:
+        """Gets data on each board and chain in the miner."""
+        logging.debug(f"{self}: Getting board info.")
+        devdetails = await self.api.devdetails()
+        if not devdetails.get("DEVDETAILS"):
+            print("devdetails error", devdetails)
+            return {0: [], 1: [], 2: []}
+        devs = devdetails["DEVDETAILS"]
+        boards = {}
+        offset = devs[0]["ID"]
+        for board in devs:
+            boards[board["ID"] - offset] = []
+            if not board["Chips"] == self.nominal_chips:
+                nominal = False
+            else:
+                nominal = True
+            if not board["Chips"] == self.nominal_chips:
+                nominal = False
+            else:
+                nominal = True
+            boards[board["ID"] - offset].append(
+                {
+                    "chain": board["ID"] - offset,
+                    "chip_count": board["Chips"],
+                    "chip_status": "o" * board["Chips"],
+                    "nominal": nominal,
+                }
+            )
+        logging.debug(f"Found board data for {self}: {boards}")
+        return boards
+
+    async def get_bad_boards(self) -> dict:
+        """Checks for and provides list of non working boards."""
+        boards = await self.get_board_info()
+        bad_boards = {}
+        for board in boards.keys():
+            for chain in boards[board]:
+                if not chain["chip_count"] == 63:
+                    if board not in bad_boards.keys():
+                        bad_boards[board] = []
+                    bad_boards[board].append(chain)
+        return bad_boards
+
+    async def check_good_boards(self) -> str:
+        """Checks for and provides list for working boards."""
+        devs = await self.api.devdetails()
+        bad = 0
+        chains = devs["DEVDETAILS"]
+        for chain in chains:
+            if chain["Chips"] == 0:
+                bad += 1
+        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,
+            "Total": 0,
+            "Ideal": self.nominal_chips * 3,
+            "Left Board": 0,
+            "Center Board": 0,
+            "Right Board": 0,
+            "Nominal": False,
+            "Split": "0",
+            "Pool 1": "Unknown",
+            "Pool 1 User": "Unknown",
+            "Pool 2": "",
+            "Pool 2 User": "",
+        }
+        model = await self.get_model()
+        hostname = await self.get_hostname()
+
+        if model:
+            data["Model"] = model
+
+        if hostname:
+            data["Hostname"] = hostname
+
+        miner_data = None
+        for i in range(DATA_RETRIES):
+            miner_data = await self.api.multicommand(
+                "summary", "temps", "tunerstatus", "pools", "devdetails"
+            )
+            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]
+        devdetails = miner_data.get("devdetails")[0]
+
+        if summary:
+            hr = summary.get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("MHS av")
+                    if hr:
+                        data["Hashrate"] = round(hr / 1000000, 2)
+
+        if temps:
+            temp = temps.get("TEMPS")
+            if temp:
+                if len(temp) > 0:
+                    temp = temp[0].get("Chip")
+                    if temp:
+                        data["Temperature"] = round(temp)
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools.get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                pool_1 = pool_1.replace("stratum+tcp://", "")
+                pool_1 = pool_1.replace("stratum2+tcp://", "")
+                data["Pool 1"] = pool_1
+
+            if pool_1_user:
+                data["Pool 1 User"] = pool_1_user
+                data["Pool 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
+
+            if pool_2_user:
+                data["Pool 2 User"] = pool_2_user
+
+            if quota:
+                data["Split"] = str(quota)
+
+        if tunerstatus:
+            tuner = tunerstatus.get("TUNERSTATUS")
+            if tuner:
+                if len(tuner) > 0:
+                    wattage = tuner[0].get("PowerLimit")
+                    if wattage:
+                        data["Wattage"] = wattage
+
+        if devdetails:
+            boards = devdetails.get("DEVDETAILS")
+            if boards:
+                if len(boards) > 0:
+                    board_map = {0: "Left Board", 1: "Center Board", 2: "Right Board"}
+                    offset = boards[0]["ID"]
+                    for board in boards:
+                        id = board["ID"] - offset
+                        chips = board["Chips"]
+                        data["Total"] += chips
+                        data[board_map[id]] = chips
+
+        if data["Total"] == data["Ideal"]:
+            data["Nominal"] = True
+
+        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,46 @@
+from miners import BaseMiner
+from API.bosminer import BOSMinerAPI
+import toml
+from config.bos import bos_config_convert, general_config_convert_bos
+import logging
+from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
+import asyncssh
+
+
+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

@@ -0,0 +1,226 @@
+from API.btminer import BTMinerAPI
+from miners import BaseMiner
+from API import APIError
+import logging
+from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
+
+
+class BTMiner(BaseMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+        self.api = BTMinerAPI(ip)
+        self.api_type = "BTMiner"
+
+    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.devdetails()
+        if version_data:
+            self.model = version_data["DEVDETAILS"][0]["Model"].split("V")[0]
+            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
+
+    async def get_hostname(self) -> str:
+        if self.hostname:
+            return self.hostname
+        try:
+            host_data = await self.api.get_miner_info()
+            if host_data:
+                host = host_data["Msg"]["hostname"]
+                logging.debug(f"Found hostname for {self.ip}: {host}")
+                self.hostname = host
+                return self.hostname
+        except APIError:
+            logging.warning(f"Failed to get hostname for miner: {self}")
+            return "?"
+        except Exception as e:
+            logging.warning(f"Failed to get hostname for miner: {self}")
+            return "?"
+
+    async def get_board_info(self) -> dict:
+        """Gets data on each board and chain in the miner."""
+        logging.debug(f"{self}: Getting board info.")
+        devs = await self.api.devs()
+        if not devs.get("DEVS"):
+            print("devs error", devs)
+            return {0: [], 1: [], 2: []}
+        devs = devs["DEVS"]
+        boards = {}
+        offset = devs[0]["ID"]
+        for board in devs:
+            boards[board["ID"] - offset] = []
+            if "Effective Chips" in board.keys():
+                if not board["Effective Chips"] in self.nominal_chips:
+                    nominal = False
+                else:
+                    nominal = True
+                boards[board["ID"] - offset].append(
+                    {
+                        "chain": board["ID"] - offset,
+                        "chip_count": board["Effective Chips"],
+                        "chip_status": "o" * board["Effective Chips"],
+                        "nominal": nominal,
+                    }
+                )
+            else:
+                logging.warning(f"Incorrect board data from {self}: {board}")
+                print(board)
+        logging.debug(f"Found board data for {self}: {boards}")
+        return boards
+
+    async def get_mac(self):
+        mac = ""
+        data = await self.api.get_miner_info()
+        if data:
+            if "Msg" in data.keys():
+                if "mac" in data["Msg"].keys():
+                    mac = data["Msg"]["mac"]
+        return str(mac).upper()
+
+    async def get_data(self):
+        data = {
+            "IP": str(self.ip),
+            "Model": "Unknown",
+            "Hostname": "Unknown",
+            "Hashrate": 0,
+            "Temperature": 0,
+            "Pool User": "Unknown",
+            "Wattage": 0,
+            "Total": 0,
+            "Ideal": self.nominal_chips * 3,
+            "Left Board": 0,
+            "Center Board": 0,
+            "Right Board": 0,
+            "Nominal": False,
+            "Split": "0",
+            "Pool 1": "Unknown",
+            "Pool 1 User": "Unknown",
+            "Pool 2": "",
+            "Pool 2 User": "",
+        }
+
+        try:
+            model = await self.get_model()
+            hostname = await self.get_hostname()
+        except APIError:
+            logging.warning(f"Failed to get hostname and model: {self}")
+            model = None
+            data["Model"] = "Whatsminer"
+            hostname = None
+            data["Hostname"] = "Whatsminer"
+
+        if model:
+            data["Model"] = model
+
+        if hostname:
+            data["Hostname"] = hostname
+        miner_data = None
+        for i in range(DATA_RETRIES):
+            try:
+                miner_data = await self.api.multicommand("summary", "devs", "pools")
+                if miner_data:
+                    break
+            except APIError:
+                pass
+
+        if not miner_data:
+            return data
+
+        summary = miner_data.get("summary")[0]
+        devs = miner_data.get("devs")[0]
+        pools = miner_data.get("pools")[0]
+
+        if summary:
+            summary_data = summary.get("SUMMARY")
+            if summary_data:
+                if len(summary_data) > 0:
+                    hr = summary_data[0].get("MHS av")
+                    if hr:
+                        data["Hashrate"] = round(hr / 1000000, 2)
+
+                    wattage = summary_data[0].get("Power")
+                    if wattage:
+                        data["Wattage"] = round(wattage)
+
+        if devs:
+            temp_data = devs.get("DEVS")
+            if temp_data:
+                for board in temp_data:
+                    temp = board.get("Chip Temp Avg")
+                    if temp and not temp == 0.0:
+                        data["Temperature"] = round(temp)
+                        break
+
+        if devs:
+            boards = devs.get("DEVS")
+            if boards:
+                if len(boards) > 0:
+                    board_map = {0: "Left Board", 1: "Center Board", 2: "Right Board"}
+                    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"]
+                        data["Total"] += chips
+                        data[board_map[id]] = chips
+
+        if data["Total"] == data["Ideal"]:
+            data["Nominal"] = True
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools.get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                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
+
+            if pool_1_user:
+                data["Pool 1 User"] = pool_1_user
+                data["Pool 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
+
+            if pool_2_user:
+                data["Pool 2 User"] = pool_2_user
+
+            if quota:
+                data["Split"] = str(quota)
+
+        return data

miners/_backends/cgminer.py

@@ -0,0 +1,207 @@
+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 logging
+
+
+class CGMiner(BaseMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+        self.api = CGMinerAPI(ip)
+        self.api_type = "CGMiner"
+        self.uname = "root"
+        self.pwd = "admin"
+
+    async def get_model(self):
+        if self.model:
+            return self.model
+        try:
+            version_data = await self.api.devdetails()
+        except APIError:
+            return None
+        if version_data:
+            self.model = version_data["DEVDETAILS"][0]["Model"].replace("Antminer ", "")
+            return self.model
+        return None
+
+    async def get_hostname(self) -> str:
+        if self.hostname:
+            return self.hostname
+        try:
+            async with (await self._get_ssh_connection()) as conn:
+                if conn is not None:
+                    data = await conn.run("cat /proc/sys/kernel/hostname")
+                    host = data.stdout.strip()
+                    self.hostname = host
+                    return self.hostname
+                else:
+                    return "?"
+        except Exception:
+            return "?"
+
+    async def send_ssh_command(self, cmd):
+        result = None
+        async with (await self._get_ssh_connection()) as conn:
+            for i in range(3):
+                try:
+                    result = await conn.run(cmd)
+                    result = result.stdout
+                except Exception as e:
+                    print(f"{cmd} error: {e}")
+                    if i == 3:
+                        return
+                    continue
+        return result
+
+    async def restart_backend(self) -> bool:
+        return await self.restart_cgminer()
+
+    async def restart_cgminer(self) -> bool:
+        commands = ["cgminer-api restart", "/usr/bin/cgminer-monitor >/dev/null 2>&1"]
+        commands = ";".join(commands)
+        _ret = await self.send_ssh_command(commands)
+        if isinstance(_ret, str):
+            return True
+        return False
+
+    async def reboot(self) -> bool:
+        logging.debug(f"{self}: Sending reboot command.")
+        _ret = await self.send_ssh_command("reboot")
+        logging.debug(f"{self}: Reboot command completed.")
+        if isinstance(_ret, str):
+            return True
+        return False
+
+    async def start_cgminer(self) -> None:
+        commands = [
+            "mkdir -p /etc/tmp/",
+            'echo "*/3 * * * * /usr/bin/cgminer-monitor" > /etc/tmp/root',
+            "crontab -u root /etc/tmp/root",
+            "/usr/bin/cgminer-monitor >/dev/null 2>&1",
+        ]
+        commands = ";".join(commands)
+        await self.send_ssh_command(commands)
+
+    async def stop_cgminer(self) -> None:
+        commands = [
+            "mkdir -p /etc/tmp/",
+            'echo "" > /etc/tmp/root',
+            "crontab -u root /etc/tmp/root",
+            "killall cgminer",
+        ]
+        commands = ";".join(commands)
+        await self.send_ssh_command(commands)
+
+    async def get_config(self) -> None:
+        async with (await self._get_ssh_connection()) as conn:
+            command = "cat /etc/config/cgminer"
+            result = await conn.run(command, check=True)
+            self.config = result.stdout
+            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": "",
+        }
+
+        model = await self.get_model()
+        hostname = await self.get_hostname()
+
+        if model:
+            data["Model"] = model
+
+        if hostname:
+            data["Hostname"] = hostname
+        miner_data = None
+        for i in range(DATA_RETRIES):
+            miner_data = await self.api.multicommand("summary", "pools", "stats")
+            if miner_data:
+                break
+
+        if not miner_data:
+            return data
+
+        summary = miner_data.get("summary")[0]
+        pools = miner_data.get("pools")[0]
+        stats = miner_data.get("stats")[0]
+
+        if summary:
+            hr = summary.get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("GHS av")
+                    if hr:
+                        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)
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools.get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                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
+
+            if pool_1_user:
+                data["Pool 1 User"] = pool_1_user
+                data["Pool 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
+
+            if pool_2_user:
+                data["Pool 2 User"] = pool_2_user
+
+            if quota:
+                data["Split"] = str(quota)
+
+        return data

miners/_backends/hiveon.py

@@ -1,19 +1,18 @@
-from miners.bmminer import BMMiner
+from miners._backends import BMMiner
 
 
-class HiveonT9(BMMiner):
+class Hiveon(BMMiner):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
-        self.model = "T9"
+        self.ip = 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."""
         board_stats = await self.api.stats()
-        stats = board_stats['STATS'][1]
+        stats = board_stats["STATS"][1]
         boards = {}
         board_chains = {0: [2, 9, 10], 1: [3, 11, 12], 2: [4, 13, 14]}
         for idx, board in enumerate(board_chains):
@@ -25,12 +24,14 @@ class HiveonT9(BMMiner):
                     nominal = False
                 else:
                     nominal = True
-                boards[board].append({
-                    "chain": chain,
-                    "chip_count": count,
-                    "chip_status": chips,
-                    "nominal": nominal
-                })
+                boards[board].append(
+                    {
+                        "chain": chain,
+                        "chip_count": count,
+                        "chip_status": chips,
+                        "nominal": nominal,
+                    }
+                )
         return boards
 
     async def get_bad_boards(self) -> dict:

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,9 @@
+from miners import BaseMiner
+
+
+class S17(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S17"
+        self.nominal_chips = 48

miners/_types/antminer/X17/S17_Plus.py

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

miners/_types/antminer/X17/S17_Pro.py

@@ -0,0 +1,9 @@
+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

miners/_types/antminer/X17/S17e.py

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

miners/_types/antminer/X17/T17.py

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

miners/_types/antminer/X17/T17_Plus.py

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

miners/_types/antminer/X17/T17e.py

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

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,9 @@
+from miners import BaseMiner
+
+
+class S19(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S19"
+        self.nominal_chips = 76

miners/_types/antminer/X19/S19_Pro.py

@@ -0,0 +1,9 @@
+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

miners/_types/antminer/X19/S19a.py

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

miners/_types/antminer/X19/S19j.py

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

miners/_types/antminer/X19/S19j_Pro.py

@@ -0,0 +1,9 @@
+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

miners/_types/antminer/X19/T19.py

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

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,9 @@
+from miners import BaseMiner
+
+
+class S9(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "S9"
+        self.nominal_chips = 63

miners/_types/antminer/X9/T9.py

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

miners/_types/antminer/X9/__init__.py

@@ -0,0 +1,2 @@
+from .S9 import S9
+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,9 @@
+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

miners/_types/avalonminer/A10X/A1066.py

@@ -0,0 +1,9 @@
+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

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,8 @@
+from miners import BaseMiner
+
+
+class Avalon821(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 821"

miners/_types/avalonminer/A8X/A841.py

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

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,9 @@
+from miners import BaseMiner
+
+
+class M20S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M20S"
+        self.nominal_chips = 66

miners/_types/whatsminer/M2X/M20S_Plus.py

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

miners/_types/whatsminer/M2X/M21.py

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

miners/_types/whatsminer/M2X/M21S.py

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

miners/_types/whatsminer/M2X/M21S_Plus.py

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

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 M21S
+from .M21S_Plus import M21SPlus

miners/_types/whatsminer/M3X/M30S.py

@@ -0,0 +1,8 @@
+from miners import BaseMiner
+
+
+class M30S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S"

miners/_types/whatsminer/M3X/M30S_Plus.py

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

miners/_types/whatsminer/M3X/M30S_Plus_Plus.py

@@ -0,0 +1,12 @@
+from miners import BaseMiner
+
+
+class M30SPlusPlus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M30S++"
+        self.nominal_chips = 117
+
+
+# TODO: handle different chip counts, 111, 117,(128)

miners/_types/whatsminer/M3X/M31S.py

@@ -0,0 +1,8 @@
+from miners import BaseMiner
+
+
+class M31S(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M31S"

miners/_types/whatsminer/M3X/M31S_Plus.py

@@ -0,0 +1,8 @@
+from miners import BaseMiner
+
+
+class M31SPlus(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "M31S+"

miners/_types/whatsminer/M3X/M32S.py

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

miners/_types/whatsminer/M3X/__init__.py

@@ -0,0 +1,8 @@
+from .M30S import M30S
+from .M30S_Plus import M30SPlus
+from .M30S_Plus_Plus import M30SPlusPlus
+
+from .M31S import M31S
+from .M31S_Plus import M31SPlus
+
+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,11 +0,0 @@
-from miners.bosminer import BOSMiner
-
-
-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/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,18 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-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:
-            return self.model
-        version_data = await self.api.version()
-        if version_data:
-            self.model = version_data["VERSION"][0]["Type"].replace("Antminer ", "")
-            return self.model
-        return None

miners/antminer/X19/cgminer.py

@@ -1,19 +0,0 @@
-from miners.cgminer import CGMiner
-
-
-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:
-            return self.model
-        version_data = await self.api.version()
-        if version_data:
-            self.model = version_data["VERSION"][0]["Type"].replace("Antminer ", "")
-            return self.model
-        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,8 @@
+from miners._backends import BMMiner
+from miners._types import S17
+
+
+class BMMinerS17(BMMiner, S17):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X17/S17_Plus.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S17Plus
+
+
+class BMMinerS17Plus(BMMiner, S17Plus):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X17/S17_Pro.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S17Pro
+
+
+class BMMinerS17Pro(BMMiner, S17Pro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X17/S17e.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S17e
+
+
+class BMMinerS17e(BMMiner, S17e):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X17/T17.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import T17
+
+
+class BMMinerT17(BMMiner, T17):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X17/T17_Plus.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import T17Plus
+
+
+class BMMinerT17Plus(BMMiner, T17Plus):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X17/T17e.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import T17e
+
+
+class BMMinerT17e(BMMiner, T17e):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

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,8 @@
+from miners._backends import BMMiner
+from miners._types import S19
+
+
+class BMMinerS19(BMMiner, S19):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X19/S19_Pro.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S19Pro
+
+
+class BMMinerS19Pro(BMMiner, S19Pro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X19/S19a.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S19a
+
+
+class BMMinerS19a(BMMiner, S19a):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X19/S19j.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S19j
+
+
+class BMMinerS19j(BMMiner, S19j):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X19/S19j_Pro.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import S19jPro
+
+
+class BMMinerS19jPro(BMMiner, S19jPro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bmminer/X19/T19.py

@@ -0,0 +1,8 @@
+from miners._backends import BMMiner
+from miners._types import T19
+
+
+class BMMinerT19(BMMiner, T19):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

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
+from miners._types import S9
+
+
+class BMMinerS9(BMMiner, S9):
+    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
+from miners._types import T9
+
+
+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,2 @@
+from .S9 import BMMinerS9
+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
+from miners._types import S17
+
+
+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
+from miners._types import S17Plus
+
+
+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
+from miners._types import S17Pro
+
+
+class BOSMinerS17Pro(BOSMiner, S17Pro):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bosminer/X17/S17e.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner
+from miners._types import S17e
+
+
+class BOSMinerS17e(BOSMiner, S17e):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bosminer/X17/T17.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner
+from miners._types import T17
+
+
+class BOSMinerT17(BOSMiner, T17):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bosminer/X17/T17_Plus.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner
+from miners._types import T17Plus
+
+
+class BOSMinerT17Plus(BOSMiner, T17Plus):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip

miners/antminer/bosminer/X17/T17e.py

@@ -0,0 +1,8 @@
+from miners._backends import BOSMiner
+from miners._types import T17e
+
+
+class BOSMinerT17e(BOSMiner, T17e):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip