fixed logfile in settings to allow for adding or removing a logfile

.gitignore

@@ -0,0 +1,7 @@
+venv/
+build/
+__pycache__/
+pyvenv.cfg
+.env/
+bin/
+lib/

API/__init__.py

@@ -171,7 +171,10 @@ If you are sure you want to use this command please use API.send_command("{item}
                 return False, data["Msg"]
         else:
             # make sure the command succeeded
-            if data["STATUS"][0]["STATUS"] not in ("S", "I"):
+            if type(data["STATUS"]) == str:
+                if data["STATUS"] in ["RESTART"]:
+                    return True, None
+            elif data["STATUS"][0]["STATUS"] not in ("S", "I"):
                 # this is an error
                 if data["STATUS"][0]["STATUS"] not in ("S", "I"):
                     return False, data["STATUS"][0]["Msg"]
@@ -197,8 +200,12 @@ 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()
+            # fix an error with Avalonminers returning inf and nan
             str_data = str_data.replace("inf", "0")
+            str_data = str_data.replace("nan", "0")
+            # fix whatever this garbage from avalonminers is `,"id":1}`
+            if str_data.startswith(","):
+                str_data = f"{{{str_data[1:]}"
             # parse the json
             parsed_data = json.loads(str_data)
         # handle bad json

API/bmminer.py

@@ -126,7 +126,7 @@ class BMMinerAPI(BaseMinerAPI):
         :return: A confirmation of adding the pool.
         """
         return await self.send_command(
-            "addpool", parameters=f"{url}, " f"{username}, " f"{password}"
+            "addpool", parameters=f"{url},{username},{password}"
         )
 
     async def poolpriority(self, *n: int) -> dict:
@@ -147,7 +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},{q}")
 
     async def disablepool(self, n: int) -> dict:
         """Disable a pool.
@@ -326,7 +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},{n}")
 
     async def usbstats(self) -> dict:
         """Get stats of all USB devices except ztex.
@@ -354,11 +354,9 @@ 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},{opt},{val}")
         else:
-            return await self.send_command("pgaset", parameters=f"{n}, " f"{opt}")
+            return await self.send_command("pgaset", parameters=f"{n},{opt}")
 
     async def zero(self, which: str, summary: bool) -> dict:
         """Zero a device.
@@ -373,7 +371,7 @@ class BMMinerAPI(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},{summary}")
 
     async def hotplug(self, n: int) -> dict:
         """Enable hotplug.
@@ -474,9 +472,9 @@ class BMMinerAPI(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},{opt},{val}")
         else:
-            return await self.send_command("ascset", parameters=f"{n}, {opt}")
+            return await self.send_command("ascset", parameters=f"{n},{opt}")
 
     async def lcd(self) -> dict:
         """Get a general all-in-one status summary of the miner.

API/bosminer.py

@@ -158,7 +158,7 @@ class BOSMinerAPI(BaseMinerAPI):
     async def addpool(self, url: str, username: str, password: str) -> dict:
         # BOS has not implemented this yet, they will in the future
         raise NotImplementedError
-        # return await self.send_command("addpool", parameters=f"{url}, {username}, {password}")
+        # return await self.send_command("addpool", parameters=f"{url},{username},{password}")
 
     async def removepool(self, n: int) -> dict:
         # BOS has not implemented this yet, they will in the future

API/cgminer.py

@@ -122,7 +122,7 @@ class CGMinerAPI(BaseMinerAPI):
         :return: A confirmation of adding the pool.
         """
         return await self.send_command(
-            "addpool", parameters=f"{url}, " f"{username}, " f"{password}"
+            "addpool", parameters=f"{url},{username},{password}"
         )
 
     async def poolpriority(self, *n: int) -> dict:
@@ -143,7 +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},{q}")
 
     async def disablepool(self, n: int) -> dict:
         """Disable a pool.
@@ -322,7 +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},{n}")
 
     async def usbstats(self) -> dict:
         """Get stats of all USB devices except ztex.
@@ -350,11 +350,9 @@ class CGMinerAPI(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},{opt},{val}")
         else:
-            return await self.send_command("pgaset", parameters=f"{n}, " f"{opt}")
+            return await self.send_command("pgaset", parameters=f"{n},{opt}")
 
     async def zero(self, which: str, summary: bool) -> dict:
         """Zero a device.
@@ -369,7 +367,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}, " f"{summary}")
+        return await self.send_command("zero", parameters=f"{which},{summary}")
 
     async def hotplug(self, n: int) -> dict:
         """Enable hotplug.
@@ -470,11 +468,9 @@ class CGMinerAPI(BaseMinerAPI):
         :return: Confirmation of setting option opt to value val.
         """
         if val:
-            return await self.send_command(
-                "ascset", parameters=f"{n}, " f"{opt}, " f"{val}"
-            )
+            return await self.send_command("ascset", parameters=f"{n},{opt},{val}")
         else:
-            return await self.send_command("ascset", parameters=f"{n}, " f"{opt}")
+            return await self.send_command("ascset", parameters=f"{n},{opt}")
 
     async def lcd(self) -> dict:
         """Get a general all-in-one status summary of the miner.

API/unknown.py

@@ -72,7 +72,7 @@ class UnknownAPI(BaseMinerAPI):
     async def addpool(self, url: str, username: str, password: str) -> dict:
         # BOS has not implemented this yet, they will in the future
         raise NotImplementedError
-        # return await self.send_command("addpool", parameters=f"{url}, {username}, {password}")
+        # return await self.send_command("addpool", parameters=f"{url},{username},{password}")
 
     async def removepool(self, n: int) -> dict:
         # BOS has not implemented this yet, they will in the future

README.md

@@ -9,7 +9,7 @@ For those of you who aren't comfortable with code and developer tools, there are
 *CFG Util is a GUI for interfacing with the miners easily, it is mostly self-explanatory.*
 
 To use CFG Util you have 2 options -
-1. Run it directly with the file ```config_tool.py``` or import it with ```from cfg_util import main```, then run the ```main()``` function in an asyncio event loop like -
+1. Run it directly with the file ```config_tool.py``` or import it with ```from cfg_util import main```, then run the ```main()``` function like -
 
 ```python
 from tools.cfg_util import main
@@ -20,7 +20,7 @@ if __name__ == '__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/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.
+   2. Navigate to this directory, and run ```make_cfg_tool_exe.py build``` on Windows or ```python3 make_cfg_tool_exe.py build``` on Mac or UNIX.
 
 ### Interfacing with miners programmatically
 <br>
@@ -48,7 +48,6 @@ 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_old.func.parse_data import safe_parse_api_data
 
 
 async def get_hashrate():
@@ -60,18 +59,11 @@ async def get_hashrate():
     # Miner Network scan function returns Miner classes for all miners found
     miners = await miner_network.scan_network_for_miners()
     # Each miner will return with its own set of functions, and an API class instance
-    tasks = [miner.api.summary() for miner in miners]
+    tasks = [miner.get_data() for miner in miners]
     # Gather all tasks asynchronously and run them
     data = await asyncio.gather(*tasks)
-    parse_tasks = []
-    for item in data:
-        # 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
-        parse_tasks.append(safe_parse_api_data(item, 'SUMMARY', 0, 'MHS 5s'))
-    # Gather all tasks asynchronously and run them
-    data = await asyncio.gather(*parse_tasks)
-    # Print a list of all the hashrates
-    print(data)
+    # now we have a list of MinerData, and can get .hashrate
+    print([item.hashrate for item in data])
 
 
 if __name__ == '__main__':
@@ -84,7 +76,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_old.func.parse_data import safe_parse_api_data
+
 
 
 async def get_miner_hashrate(ip: str):
@@ -95,11 +87,9 @@ async def get_miner_hashrate(ip: str):
     # Wait for the factory to return the miner
     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, 'MHS 5s')
-    print(data)
+    data = await miner.get_data()
+    # print out hashrate
+    print(data.hashrate)
 
 
 if __name__ == '__main__':
@@ -112,6 +102,7 @@ Now that you know that, lets move on to some common API functions that you might
 
 ### Common commands:
 * Get the data used by the config utility, this includes pool data, wattage use, temperature, hashrate, etc:
+* All the data from below commands and more are returned from this in a consistent dataclass.  Check out the `MinerData` class in  `/data/__init__.py` for more information.
 
 ```python
 import asyncio

config/__init__.py

@@ -1,88 +1,366 @@
-"""
-SAMPLE CONFIG
--------------------
-{
-    "format": {
-        "version": "1.2+", # -> (default = "1.2+", str, (bos: format.version))
-        "model": "Antminer S9", # -> (default = "Antminer S9", str, (bos: format.model))
-        "generator": "upstream_config_util", # -> (hidden, always = "upstream_config_util", str, (bos: format.generator))
-        "timestamp": 1606842000, # -> (hidden, always = int(time.time()) (current unix time), int, (bos: format.timestamp))
-    },
-    "temperature": {
-        "mode": "auto", # -> (default = "auto", str["auto", "manual", "disabled"], (bos: temp_control.mode))
-        "target": 70.0, # -> (default = 70.0, float, (bos: temp_control.target_temp))
-        "hot": 80.0, # -> (default = 80.0, float, (bos: temp_control.hot_temp))
-        "danger": 90.0, # -> (default = 90.0, float, (bos: temp_control.dangerous_temp))
-    },
-    "fans": { # -> (optional, required if temperature["mode"] == "disabled", (bos: fan_control))
-        "min_fans": 1, # -> (default = 1, int, (bos: fan_control.min_fans))
-        "speed": 100, # -> (default = 100, 0 < int < 100, (bos: fan_control.speed))
-    },
-    "asicboost": True, # -> (default = True, bool, (bos : hash_chain_global.asic_boost))
-    "pool_groups": [
-        {
-            "group_name": "Upstream", # -> (default = "group_{index}" (group_0), str, (bos: group.[index].name))
-            "quota": 1, # -> (default = 1, int, (bos: group.[index].quota))
-            "pools": [
-                {
-                    "url": "stratum+tcp://stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataInc.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://us-east.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataInc.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://ca.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataInc.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-            ]
-        },
-        {
-            "group_name": "Upstream2", # -> (default = "group_{index}" (group_1), str, (bos: group.[index].name))
-            "quota": 4, # -> (default = 1, int, (bos: group.[index].quota))
-            "pools": [
-                {
-                    "url": "stratum+tcp://stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataTesting.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://us-east.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataTesting.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://ca.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataTesting.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-            ]
-        },
-    ],
-    "autotuning": {
-        "enabled": True, # -> (default = True, bool), (bos: autotuning.enabled)
-        "wattage": 900, # -> (default = 900, int, (bos: autotuning.psu_power_limit))
-    },
-    "power_scaling": {
-        "enabled": False, # -> (default = False, bool, (bos: power_scaling.enabled))
-        "power_step": 100, # -> (default = 100, int, (bos: power_scaling.power_step))
-        "min_psu_power_limit": 800, # -> (default = 800, int, (bos: power_scaling.min_psu_power_limit))
-        "shutdown_enabled": True, # -> (default = False, bool, (bos: power_scaling.shutdown_enabled))
-        "shutdown_duration": 3.0, # -> (default = 3.0, float, (bos: power_scaling.shutdown_duration))
-    }
-}
-"""
+from dataclasses import dataclass, asdict
+from typing import List, Literal
+import random
+import string
+
+import toml
+import yaml
+import json
+import time
 
 
-def general_config_convert_pools(config: dict):
-    out_config = {}
-    pools = config.get("pool_groups")
-    if pools:
-        if len(pools) > 0:
-            pools = pools[0]
-            out_config = pools["pools"][:3]
-    return out_config
+@dataclass
+class _Pool:
+    """A dataclass for pool information.
+
+    :param url: URL of the pool.
+    :param username: Username on the pool.
+    :param password: Worker password on the pool.
+    """
+
+    url: str = ""
+    username: str = ""
+    password: str = ""
+
+    def from_dict(self, data: dict):
+        """Convert raw pool data as a dict to usable data and save it to this class.
+
+        :param data: The raw config data to convert.
+        """
+        for key in data.keys():
+            if key == "url":
+                self.url = data[key]
+            if key in ["user", "username"]:
+                self.username = data[key]
+            if key in ["pass", "password"]:
+                self.password = data[key]
+        return self
+
+    def as_x19(self, user_suffix: str = None):
+        """Convert the data in this class to a dict usable by an X19 device.
+
+        :param user_suffix: The suffix to append to username.
+        """
+        username = self.username
+        if user_suffix:
+            username = f"{username}{user_suffix}"
+
+        pool = {"url": self.url, "user": username, "pass": self.password}
+        return pool
+
+    def as_avalon(self, user_suffix: str = None):
+        username = self.username
+        if user_suffix:
+            username = f"{username}{user_suffix}"
+
+        pool = ",".join([self.url, username, self.password])
+        return pool
+
+    def as_bos(self, user_suffix: str = None):
+        """Convert the data in this class to a dict usable by an BOSMiner device.
+
+        :param user_suffix: The suffix to append to username.
+        """
+        username = self.username
+        if user_suffix:
+            username = f"{username}{user_suffix}"
+
+        pool = {"url": self.url, "user": username, "password": self.password}
+        return pool
+
+
+@dataclass
+class _PoolGroup:
+    """A dataclass for pool group information.
+
+    :param quota: The group quota.
+    :param group_name: The name of the pool group.
+    :param pools: A list of pools in this group.
+    """
+
+    quota: int = 1
+    group_name: str = None
+    pools: List[_Pool] = None
+
+    def __post_init__(self):
+        if not self.group_name:
+            self.group_name = "".join(
+                random.choice(string.ascii_uppercase + string.digits) for _ in range(6)
+            )  # generate random pool group name in case it isn't set
+
+    def from_dict(self, data: dict):
+        """Convert raw pool group data as a dict to usable data and save it to this class.
+
+        :param data: The raw config data to convert.
+        """
+        pools = []
+        for key in data.keys():
+            if key in ["name", "group_name"]:
+                self.group_name = data[key]
+            if key == "quota":
+                self.quota = data[key]
+            if key in ["pools", "pool"]:
+                for pool in data[key]:
+                    pools.append(_Pool().from_dict(pool))
+        self.pools = pools
+        return self
+
+    def as_x19(self, user_suffix: str = None):
+        """Convert the data in this class to a dict usable by an X19 device.
+
+        :param user_suffix: The suffix to append to username.
+        """
+        pools = []
+        for pool in self.pools[:3]:
+            pools.append(pool.as_x19(user_suffix=user_suffix))
+        return pools
+
+    def as_avalon(self, user_suffix: str = None):
+        pool = self.pools[0].as_avalon(user_suffix=user_suffix)
+        return pool
+
+    def as_bos(self, user_suffix: str = None):
+        """Convert the data in this class to a dict usable by an BOSMiner device.
+
+        :param user_suffix: The suffix to append to username.
+        """
+        group = {
+            "name": self.group_name,
+            "quota": self.quota,
+            "pool": [pool.as_bos(user_suffix=user_suffix) for pool in self.pools],
+        }
+        return group
+
+
+@dataclass
+class MinerConfig:
+    """A dataclass for miner configuration information.
+
+    :param pool_groups: A list of pool groups in this config.
+    :param temp_mode: The temperature control mode.
+    :param temp_target: The target temp.
+    :param temp_hot: The hot temp (100% fans).
+    :param temp_dangerous: The dangerous temp (shutdown).
+    :param minimum_fans: The minimum numbers of fans to run the miner.
+    :param fan_speed: Manual fan speed to run the fan at (only if temp_mode == "manual").
+    :param asicboost: Whether or not to enable asicboost.
+    :param autotuning_enabled: Whether or not to enable autotuning.
+    :param autotuning_wattage: The wattage to use when autotuning.
+    :param dps_enabled: Whether or not to enable dynamic power scaling.
+    :param dps_power_step: The amount of power to reduce autotuning by when the miner reaches dangerous temp.
+    :param dps_min_power: The minimum power to reduce autotuning to.
+    :param dps_shutdown_enabled: Whether or not to shutdown the miner when `dps_min_power` is reached.
+    :param dps_shutdown_duration: The amount of time to shutdown for (in hours).
+    """
+
+    pool_groups: List[_PoolGroup] = None
+
+    temp_mode: Literal["auto", "manual", "disabled"] = "auto"
+    temp_target: float = 70.0
+    temp_hot: float = 80.0
+    temp_dangerous: float = 10.0
+
+    minimum_fans: int = None
+    fan_speed: Literal[tuple(range(101))] = None  # noqa - Ignore weird Literal usage
+
+    asicboost: bool = None
+
+    autotuning_enabled: bool = True
+    autotuning_wattage: int = 900
+
+    dps_enabled: bool = None
+    dps_power_step: int = None
+    dps_min_power: int = None
+    dps_shutdown_enabled: bool = None
+    dps_shutdown_duration: float = None
+
+    def as_dict(self):
+        """Convert the data in this class to a dict."""
+
+        data_dict = asdict(self)
+        for key in asdict(self).keys():
+            if data_dict[key] is None:
+                del data_dict[key]
+        return data_dict
+
+    def as_toml(self):
+        """Convert the data in this class to toml."""
+        return toml.dumps(self.as_dict())
+
+    def as_yaml(self):
+        """Convert the data in this class to yaml."""
+        return yaml.dump(self.as_dict(), sort_keys=False)
+
+    def from_raw(self, data: dict):
+        """Convert raw config data as a dict to usable data and save it to this class.
+
+        :param data: The raw config data to convert.
+        """
+        pool_groups = []
+        for key in data.keys():
+            if key == "pools":
+                pool_groups.append(_PoolGroup().from_dict({"pools": data[key]}))
+            elif key == "group":
+                for group in data[key]:
+                    pool_groups.append(_PoolGroup().from_dict(group))
+
+            if key == "bitmain-fan-ctrl":
+                if data[key]:
+                    self.temp_mode = "manual"
+                    if data.get("bitmain-fan-pwm"):
+                        self.fan_speed = int(data["bitmain-fan-pwm"])
+            elif key == "fan_control":
+                for _key in data[key].keys():
+                    if _key == "min_fans":
+                        self.minimum_fans = data[key][_key]
+                    elif _key == "speed":
+                        self.fan_speed = data[key][_key]
+            elif key == "temp_control":
+                for _key in data[key].keys():
+                    if _key == "mode":
+                        self.temp_mode = data[key][_key]
+                    elif _key == "target_temp":
+                        self.temp_target = data[key][_key]
+                    elif _key == "hot_temp":
+                        self.temp_hot = data[key][_key]
+                    elif _key == "dangerous_temp":
+                        self.temp_dangerous = data[key][_key]
+
+            if key == "hash_chain_global":
+                if data[key].get("asic_boost"):
+                    self.asicboost = data[key]["asic_boost"]
+
+            if key == "autotuning":
+                for _key in data[key].keys():
+                    if _key == "enabled":
+                        self.autotuning_enabled = data[key][_key]
+                    elif _key == "psu_power_limit":
+                        self.autotuning_wattage = data[key][_key]
+
+            if key == "power_scaling":
+                for _key in data[key].keys():
+                    if _key == "enabled":
+                        self.dps_enabled = data[key][_key]
+                    elif _key == "power_step":
+                        self.dps_power_step = data[key][_key]
+                    elif _key == "min_psu_power_limit":
+                        self.dps_min_power = data[key][_key]
+                    elif _key == "shutdown_enabled":
+                        self.dps_shutdown_enabled = data[key][_key]
+                    elif _key == "shutdown_duration":
+                        self.dps_shutdown_duration = data[key][_key]
+
+        self.pool_groups = pool_groups
+        return self
+
+    def from_dict(self, data: dict):
+        """Convert an output dict of this class back into usable data and save it to this class.
+
+        :param data: The raw config data to convert.
+        """
+        pool_groups = []
+        for group in data["pool_groups"]:
+            pool_groups.append(_PoolGroup().from_dict(group))
+        for key in data.keys():
+            if getattr(self, key) and not key == "pool_groups":
+                setattr(self, key, data[key])
+        self.pool_groups = pool_groups
+        return self
+
+    def from_toml(self, data: str):
+        """Convert output toml of this class back into usable data and save it to this class.
+
+        :param data: The raw config data to convert.
+        """
+        return self.from_dict(toml.loads(data))
+
+    def from_yaml(self, data: str):
+        """Convert output yaml of this class back into usable data and save it to this class.
+
+        :param data: The raw config data to convert.
+        """
+        return self.from_dict(yaml.load(data, Loader=yaml.SafeLoader))
+
+    def as_x19(self, user_suffix: str = None) -> str:
+        """Convert the data in this class to a config usable by an X19 device.
+
+        :param user_suffix: The suffix to append to username.
+        """
+        cfg = {
+            "pools": self.pool_groups[0].as_x19(user_suffix=user_suffix),
+            "bitmain-fan-ctrl": False,
+            "bitmain-fan-pwn": 100,
+        }
+
+        if not self.temp_mode == "auto":
+            cfg["bitmain-fan-ctrl"] = True
+
+        if self.fan_speed:
+            cfg["bitmain-fan-ctrl"] = str(self.fan_speed)
+
+        return json.dumps(cfg)
+
+    def as_avalon(self, user_suffix: str = None) -> str:
+        cfg = self.pool_groups[0].as_avalon()
+        return cfg
+
+    def as_bos(self, model: str = "S9", user_suffix: str = None) -> str:
+        """Convert the data in this class to a config usable by an BOSMiner device.
+
+        :param model: The model of the miner to be used in the format portion of the config.
+        :param user_suffix: The suffix to append to username.
+        """
+        cfg = {
+            "format": {
+                "version": "1.2+",
+                "model": f"Antminer {model}",
+                "generator": "Upstream Config Utility",
+                "timestamp": int(time.time()),
+            },
+            "group": [
+                group.as_bos(user_suffix=user_suffix) for group in self.pool_groups
+            ],
+            "temp_control": {
+                "mode": self.temp_mode,
+                "target_temp": self.temp_target,
+                "hot_temp": self.temp_hot,
+                "dangerous_temp": self.temp_dangerous,
+            },
+        }
+
+        if self.autotuning_enabled or self.autotuning_wattage:
+            cfg["autotuning"] = {}
+            if self.autotuning_enabled:
+                cfg["autotuning"]["enabled"] = self.autotuning_enabled
+            if self.autotuning_wattage:
+                cfg["autotuning"]["psu_power_limit"] = self.autotuning_wattage
+
+        if self.asicboost:
+            cfg["hash_chain_global"] = {}
+            cfg["hash_chain_global"]["asic_boost"] = self.asicboost
+
+        if any(
+            [
+                getattr(self, item)
+                for item in [
+                    "dps_enabled",
+                    "dps_power_step",
+                    "dps_min_power",
+                    "dps_shutdown_enabled",
+                    "dps_shutdown_duration",
+                ]
+            ]
+        ):
+            cfg["power_scaling"] = {}
+            if self.dps_enabled:
+                cfg["power_scaling"]["enabled"] = self.dps_enabled
+            if self.dps_power_step:
+                cfg["power_scaling"]["power_step"] = self.dps_power_step
+            if self.dps_min_power:
+                cfg["power_scaling"]["min_psu_power_limit"] = self.dps_min_power
+            if self.dps_shutdown_enabled:
+                cfg["power_scaling"]["shutdown_enabled"] = self.dps_shutdown_enabled
+            if self.dps_shutdown_duration:
+                cfg["power_scaling"]["shutdown_duration"] = self.dps_shutdown_duration
+
+        return toml.dumps(cfg)

config/bos.py

@@ -1,221 +0,0 @@
-import time
-
-import yaml
-
-
-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"]["timestamp"] = int(time.time())
-        elif opt == "temp_control":
-            out_config["temperature"] = {}
-            if "mode" in config[opt].keys():
-                out_config["temperature"]["mode"] = config[opt]["mode"]
-            else:
-                out_config["temperature"]["mode"] = "auto"
-
-            if "target_temp" in config[opt].keys():
-                out_config["temperature"]["target"] = config[opt]["target_temp"]
-            else:
-                out_config["temperature"]["target"] = 70.0
-
-            if "hot_temp" in config[opt].keys():
-                out_config["temperature"]["hot"] = config[opt]["hot_temp"]
-            else:
-                out_config["temperature"]["hot"] = 80.0
-
-            if "dangerous_temp" in config[opt].keys():
-                out_config["temperature"]["danger"] = config[opt]["dangerous_temp"]
-            else:
-                out_config["temperature"]["danger"] = 90.0
-        elif opt == "fan_control":
-            out_config["fans"] = {}
-            if "min_fans" in config[opt].keys():
-                out_config["fans"]["min_fans"] = config[opt]["min_fans"]
-            else:
-                out_config["fans"]["min_fans"] = 1
-            if "speed" in config[opt].keys():
-                out_config["fans"]["speed"] = config[opt]["speed"]
-            else:
-                out_config["fans"]["speed"] = 100
-        elif opt == "group":
-            out_config["pool_groups"] = [{} for _item in range(len(config[opt]))]
-            for idx in range(len(config[opt])):
-                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"
-                    ]
-                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"]))
-                ]
-                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"]
-        elif opt == "autotuning":
-            out_config["autotuning"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["autotuning"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["autotuning"]["enabled"] = True
-            if "psu_power_limit" in config[opt].keys():
-                out_config["autotuning"]["wattage"] = config[opt]["psu_power_limit"]
-            else:
-                out_config["autotuning"]["wattage"] = 900
-        elif opt == "power_scaling":
-            out_config["power_scaling"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["power_scaling"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["power_scaling"]["enabled"] = False
-            if "power_step" in config[opt].keys():
-                out_config["power_scaling"]["power_step"] = config[opt]["power_step"]
-            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"
-                ]
-            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"
-                ]
-            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"
-                ]
-            else:
-                out_config["power_scaling"]["shutdown_duration"] = 3.0
-    return yaml.dump(out_config, sort_keys=False)
-
-
-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"]["timestamp"] = int(time.time())
-        elif opt == "temperature":
-            out_config["temp_control"] = {}
-            if "mode" in config[opt].keys():
-                out_config["temp_control"]["mode"] = config[opt]["mode"]
-            else:
-                out_config["temp_control"]["mode"] = "auto"
-
-            if "target" in config[opt].keys():
-                out_config["temp_control"]["target_temp"] = config[opt]["target"]
-            else:
-                out_config["temp_control"]["target_temp"] = 70.0
-
-            if "hot" in config[opt].keys():
-                out_config["temp_control"]["hot_temp"] = config[opt]["hot"]
-            else:
-                out_config["temp_control"]["hot_temp"] = 80.0
-
-            if "danger" in config[opt].keys():
-                out_config["temp_control"]["dangerous_temp"] = config[opt]["danger"]
-            else:
-                out_config["temp_control"]["dangerous_temp"] = 90.0
-        elif opt == "fans":
-            out_config["fan_control"] = {}
-            if "min_fans" in config[opt].keys():
-                out_config["fan_control"]["min_fans"] = config[opt]["min_fans"]
-            else:
-                out_config["fan_control"]["min_fans"] = 1
-            if "speed" in config[opt].keys():
-                out_config["fan_control"]["speed"] = config[opt]["speed"]
-            else:
-                out_config["fan_control"]["speed"] = 100
-        elif opt == "pool_groups":
-            out_config["group"] = [{} for _item in range(len(config[opt]))]
-            for idx in range(len(config[opt])):
-                out_config["group"][idx]["pools"] = []
-                out_config["group"][idx] = {}
-                if "group_name" in config[opt][idx].keys():
-                    out_config["group"][idx]["name"] = config[opt][idx]["group_name"]
-                else:
-                    out_config["group"][idx]["name"] = f"group_{idx}"
-                if "quota" in config[opt][idx].keys():
-                    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"]))
-                ]
-                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"]
-                    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():
-                out_config["autotuning"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["autotuning"]["enabled"] = True
-            if "wattage" in config[opt].keys():
-                out_config["autotuning"]["psu_power_limit"] = config[opt]["wattage"]
-            else:
-                out_config["autotuning"]["psu_power_limit"] = 900
-        elif opt == "power_scaling":
-            out_config["power_scaling"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["power_scaling"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["power_scaling"]["enabled"] = False
-            if "power_step" in config[opt].keys():
-                out_config["power_scaling"]["power_step"] = config[opt]["power_step"]
-            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"
-                ]
-            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"
-                ]
-            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"
-                ]
-            else:
-                out_config["power_scaling"]["shutdown_duration"] = 3.0
-    return out_config

config/miner_config.py

@@ -1,317 +0,0 @@
-from dataclasses import dataclass, asdict
-from typing import List, Literal
-import random
-import string
-
-import toml
-import yaml
-import json
-import time
-
-
-@dataclass
-class _Pool:
-    url: str = ""
-    username: str = ""
-    password: str = ""
-
-    def from_dict(self, data: dict):
-        for key in data.keys():
-            if key == "url":
-                self.url = data[key]
-            if key in ["user", "username"]:
-                self.username = data[key]
-            if key in ["pass", "password"]:
-                self.password = data[key]
-        return self
-
-    def as_x19(self, user_suffix: str = None):
-        username = self.username
-        if user_suffix:
-            username = f"{username}{user_suffix}"
-
-        pool = {"url": self.url, "user": username, "pass": self.password}
-        return pool
-
-    def as_bos(self, user_suffix: str = None):
-        username = self.username
-        if user_suffix:
-            username = f"{username}{user_suffix}"
-
-        pool = {"url": self.url, "user": username, "password": self.password}
-        return pool
-
-
-@dataclass
-class _PoolGroup:
-    quota: int = 1
-    group_name: str = None
-    pools: List[_Pool] = None
-
-    def __post_init__(self):
-        if not self.group_name:
-            self.group_name = "".join(
-                random.choice(string.ascii_uppercase + string.digits) for _ in range(6)
-            )  # generate random pool group name in case it isn't set
-
-    def from_dict(self, data: dict):
-        pools = []
-        for key in data.keys():
-            if key in ["name", "group_name"]:
-                self.group_name = data[key]
-            if key == "quota":
-                self.quota = data[key]
-            if key in ["pools", "pool"]:
-                for pool in data[key]:
-                    pools.append(_Pool().from_dict(pool))
-        self.pools = pools
-        return self
-
-    def as_x19(self, user_suffix: str = None):
-        pools = []
-        for pool in self.pools[:3]:
-            pools.append(pool.as_x19(user_suffix=user_suffix))
-        return pools
-
-    def as_bos(self, user_suffix: str = None):
-        group = {
-            "name": self.group_name,
-            "quota": self.quota,
-            "pool": [pool.as_bos(user_suffix=user_suffix) for pool in self.pools],
-        }
-        return group
-
-
-@dataclass
-class MinerConfig:
-    pool_groups: List[_PoolGroup] = None
-
-    temp_mode: Literal["auto", "manual", "disabled"] = "auto"
-    temp_target: float = 70.0
-    temp_hot: float = 80.0
-    temp_dangerous: float = 10.0
-
-    minimum_fans: int = None
-    fan_speed: Literal[tuple(range(101))] = None  # noqa - Ignore weird Literal usage
-
-    asicboost: bool = None
-
-    autotuning_enabled: bool = True
-    autotuning_wattage: int = 900
-
-    dps_enabled: bool = None
-    dps_power_step: int = None
-    dps_min_power: int = None
-    dps_shutdown_enabled: bool = None
-    dps_shutdown_duration: float = None
-
-    def as_dict(self):
-        data_dict = asdict(self)
-        for key in asdict(self).keys():
-            if data_dict[key] is None:
-                del data_dict[key]
-        return data_dict
-
-    def as_toml(self):
-        return toml.dumps(self.as_dict())
-
-    def as_yaml(self):
-        return yaml.dump(self.as_dict(), sort_keys=False)
-
-    def from_raw(self, data: dict):
-        pool_groups = []
-        for key in data.keys():
-            if key == "pools":
-                pool_groups.append(_PoolGroup().from_dict({"pools": data[key]}))
-            elif key == "group":
-                for group in data[key]:
-                    pool_groups.append(_PoolGroup().from_dict(group))
-
-            if key == "bitmain-fan-ctrl":
-                if data[key]:
-                    self.temp_mode = "manual"
-                    if data.get("bitmain-fan-pwm"):
-                        self.fan_speed = int(data["bitmain-fan-pwm"])
-            elif key == "fan_control":
-                for _key in data[key].keys():
-                    if _key == "min_fans":
-                        self.minimum_fans = data[key][_key]
-                    elif _key == "speed":
-                        self.fan_speed = data[key][_key]
-            elif key == "temp_control":
-                for _key in data[key].keys():
-                    if _key == "mode":
-                        self.temp_mode = data[key][_key]
-                    elif _key == "target_temp":
-                        self.temp_target = data[key][_key]
-                    elif _key == "hot_temp":
-                        self.temp_hot = data[key][_key]
-                    elif _key == "dangerous_temp":
-                        self.temp_dangerous = data[key][_key]
-
-            if key == "hash_chain_global":
-                if data[key].get("asic_boost"):
-                    self.asicboost = data[key]["asic_boost"]
-
-            if key == "autotuning":
-                for _key in data[key].keys():
-                    if _key == "enabled":
-                        self.autotuning_enabled = data[key][_key]
-                    elif _key == "psu_power_limit":
-                        self.autotuning_wattage = data[key][_key]
-
-            if key == "power_scaling":
-                for _key in data[key].keys():
-                    if _key == "enabled":
-                        self.dps_enabled = data[key][_key]
-                    elif _key == "power_step":
-                        self.dps_power_step = data[key][_key]
-                    elif _key == "min_psu_power_limit":
-                        self.dps_min_power = data[key][_key]
-                    elif _key == "shutdown_enabled":
-                        self.dps_shutdown_enabled = data[key][_key]
-                    elif _key == "shutdown_duration":
-                        self.dps_shutdown_duration = data[key][_key]
-
-        self.pool_groups = pool_groups
-        return self
-
-    def from_dict(self, data: dict):
-        pool_groups = []
-        for group in data["pool_groups"]:
-            pool_groups.append(_PoolGroup().from_dict(group))
-        for key in data.keys():
-            if getattr(self, key) and not key == "pool_groups":
-                setattr(self, key, data[key])
-        self.pool_groups = pool_groups
-        return self
-
-    def from_toml(self, data: str):
-        return self.from_dict(toml.loads(data))
-
-    def from_yaml(self, data: str):
-        return self.from_dict(yaml.load(data, Loader=yaml.SafeLoader))
-
-    def as_x19(self, user_suffix: str = None):
-        cfg = {
-            "pools": self.pool_groups[0].as_x19(user_suffix=user_suffix),
-            "bitmain-fan-ctrl": False,
-            "bitmain-fan-pwn": 100,
-        }
-
-        if not self.temp_mode == "auto":
-            cfg["bitmain-fan-ctrl"] = True
-
-        if self.fan_speed:
-            cfg["bitmain-fan-ctrl"] = str(self.fan_speed)
-
-        return json.dumps(cfg)
-
-    def as_bos(self, model: str = "S9", user_suffix: str = None):
-        cfg = {
-            "format": {
-                "version": "1.2+",
-                "model": f"Antminer {model}",
-                "generator": "Upstream Config Utility",
-                "timestamp": int(time.time()),
-            },
-            "group": [
-                group.as_bos(user_suffix=user_suffix) for group in self.pool_groups
-            ],
-            "temp_control": {
-                "mode": self.temp_mode,
-                "target_temp": self.temp_target,
-                "hot_temp": self.temp_hot,
-                "dangerous_temp": self.temp_dangerous,
-            },
-        }
-
-        if self.autotuning_enabled or self.autotuning_wattage:
-            cfg["autotuning"] = {}
-            if self.autotuning_enabled:
-                cfg["autotuning"]["enabled"] = self.autotuning_enabled
-            if self.autotuning_wattage:
-                cfg["autotuning"]["psu_power_limit"] = self.autotuning_wattage
-
-        if self.asicboost:
-            cfg["hash_chain_global"] = {}
-            cfg["hash_chain_global"]["asic_boost"] = self.asicboost
-
-        if any(
-            [
-                getattr(self, item)
-                for item in [
-                    "dps_enabled",
-                    "dps_power_step",
-                    "dps_min_power",
-                    "dps_shutdown_enabled",
-                    "dps_shutdown_duration",
-                ]
-            ]
-        ):
-            cfg["power_scaling"] = {}
-            if self.dps_enabled:
-                cfg["power_scaling"]["enabled"] = self.dps_enabled
-            if self.dps_power_step:
-                cfg["power_scaling"]["power_step"] = self.dps_power_step
-            if self.dps_min_power:
-                cfg["power_scaling"]["min_psu_power_limit"] = self.dps_min_power
-            if self.dps_shutdown_enabled:
-                cfg["power_scaling"]["shutdown_enabled"] = self.dps_shutdown_enabled
-            if self.dps_shutdown_duration:
-                cfg["power_scaling"]["shutdown_duration"] = self.dps_shutdown_duration
-
-        return toml.dumps(cfg)
-
-
-if __name__ == "__main__":
-    import pprint
-
-    bos_conf = {
-        "group": [
-            {
-                "name": "group",
-                "pool": [
-                    {
-                        "password": "123",
-                        "url": "stratum2+tcp://v2.us-east.stratum.slushpool.com/u95GEReVMjK6k5YqiSFNqqTnKU4ypU2Wm8awa6tmbmDmk1bWt",
-                        "user": "UpstreamDataInc.test",
-                    },
-                    {
-                        "password": "123",
-                        "url": "stratum2+tcp://v2.stratum.slushpool.com/u95GEReVMjK6k5YqiSFNqqTnKU4ypU2Wm8awa6tmbmDmk1bWt",
-                        "user": "UpstreamDataInc.test",
-                    },
-                    {
-                        "password": "123",
-                        "url": "stratum+tcp://stratum.slushpool.com:3333",
-                        "user": "UpstreamDataInc.test",
-                    },
-                ],
-                "quota": 1,
-            },
-            {
-                "name": "group_2",
-                "pool": [
-                    {
-                        "password": "123",
-                        "url": "stratum2+tcp://v2.us-east.stratum.slushpool.com/u95GEReVMjK6k5YqiSFNqqTnKU4ypU2Wm8awa6tmbmDmk1bWt",
-                        "user": "UpstreamDataInc.test",
-                    },
-                    {
-                        "password": "123",
-                        "url": "stratum2+tcp://v2.stratum.slushpool.com/u95GEReVMjK6k5YqiSFNqqTnKU4ypU2Wm8awa6tmbmDmk1bWt",
-                        "user": "UpstreamDataInc.test",
-                    },
-                    {
-                        "password": "123",
-                        "url": "stratum+tcp://stratum.slushpool.com:3333",
-                        "user": "UpstreamDataInc.test",
-                    },
-                ],
-                "quota": 1,
-            },
-        ],
-    }
-
-    pprint.pprint(MinerConfig().from_dict(bos_conf).as_dict())

config/sample_config_cgminer

@@ -1,17 +0,0 @@
-
-config cgminer 'default'
-	option pool1pw 'x'
-	option pool2pw 'x'
-	option pool3pw 'x'
-	option voltage_level_offset '0'
-	option fan '10'
-	option api_allow 'W:0/0'
-	option power_mode 'balance'
-	option pool1url 'stratum+tcp://ca.stratum.slushpool.com:3333'
-	option pool1user 'poolacct.worker1'
-	option pool2url 'stratum+tcp://ca.stratum.slushpool.com:3333'
-	option pool2user 'poolacct.worker2'
-	option pool3url 'stratum+tcp://ca.stratum.slushpool.com:3333'
-	option pool3user 'poolacct.worker3'
-	option ntp_enable 'openwrt'
-

data/__init__.py

@@ -40,6 +40,7 @@ class MinerData:
     hostname: str = "Unknown"
     hashrate: float = 0
     temperature_avg: int = field(init=False)
+    env_temp: float = 0
     left_board_temp: int = 0
     left_board_chip_temp: int = 0
     center_board_temp: int = 0
@@ -100,7 +101,7 @@ class MinerData:
             self.center_board_chip_temp,
             self.right_board_chip_temp,
         ]:
-            if not temp == 0:
+            if temp and not temp == 0:
                 total_temp += temp
                 temp_count += 1
         if not temp_count > 0:

logger/__init__.py

@@ -1,14 +1,21 @@
 import logging
-from settings import DEBUG
+from settings import DEBUG, LOGFILE
 
 
 def init_logger():
-    logging.basicConfig(
-        # filename="logfile.txt",
-        # filemode="a",
-        format="%(pathname)s:%(lineno)d in %(funcName)s\n[%(levelname)s][%(asctime)s](%(name)s) - %(message)s",
-        datefmt="%x %X",
-    )
+    if LOGFILE:
+        logging.basicConfig(
+            filename="logfile.txt",
+            filemode="a",
+            format="%(pathname)s:%(lineno)d in %(funcName)s\n[%(levelname)s][%(asctime)s](%(name)s) - %(message)s",
+            datefmt="%x %X",
+        )
+    else:
+        logging.basicConfig(
+            format="%(pathname)s:%(lineno)d in %(funcName)s\n[%(levelname)s][%(asctime)s](%(name)s) - %(message)s",
+            datefmt="%x %X",
+        )
+
     _logger = logging.getLogger()
 
     if DEBUG:

miners/_backends/bmminer.py

@@ -203,11 +203,17 @@ class BMMiner(BaseMiner):
                         )
 
                     board_map = {0: "left_board", 1: "center_board", 2: "right_board"}
+                    env_temp_list = []
                     for item in range(3):
                         board_temp = temp[1].get(f"temp{item + board_offset}")
                         chip_temp = temp[1].get(f"temp2_{item + board_offset}")
                         setattr(data, f"{board_map[item]}_chip_temp", chip_temp)
                         setattr(data, f"{board_map[item]}_temp", board_temp)
+                        if f"temp_pcb{item}" in temp[1].keys():
+                            env_temp = temp[1][f"temp_pcb{item}"].split("-")[0]
+                            if not env_temp == 0:
+                                env_temp_list.append(int(env_temp))
+                    data.env_temp = sum(env_temp_list) / len(env_temp_list)
 
         if pools:
             pool_1 = None

miners/_backends/bosminer.py

@@ -11,7 +11,7 @@ from API import APIError
 
 from data import MinerData
 
-from config.miner_config import MinerConfig
+from config import MinerConfig
 
 from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
 
@@ -400,4 +400,4 @@ class BOSMiner(BaseMiner):
 
     async def get_mac(self):
         result = await self.send_ssh_command("cat /sys/class/net/eth0/address")
-        return result.upper()
+        return result.upper().strip()

miners/_backends/bosminer_old.py

@@ -1,6 +1,6 @@
 import logging
 
-import asyncssh
+import ipaddress
 
 from API.bosminer import BOSMinerAPI
 from miners import BaseMiner
@@ -9,6 +9,7 @@ from miners import BaseMiner
 class BOSMinerOld(BaseMiner):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
+        self.ip = ipaddress.ip_address(ip)
         self.api = BOSMinerAPI(ip)
         self.api_type = "BOSMiner"
         self.uname = "root"
@@ -22,14 +23,17 @@ class BOSMinerOld(BaseMiner):
         result = None
 
         # open an ssh connection
-        async with await asyncssh.connect("192.168.1.11", username="root") as conn:
+        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
+                    if result.stdout:
+                        result = result.stdout
                 except Exception as e:
+                    if e == "SSH connection closed":
+                        return "Update completed."
                     # if the command fails, log it
                     logging.warning(f"{self} command {cmd} error: {e}")
 
@@ -40,6 +44,7 @@ class BOSMinerOld(BaseMiner):
         # 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

@@ -30,7 +30,7 @@ class BTMiner(BaseMiner):
         logging.warning(f"Failed to get model for miner: {self}")
         return None
 
-    async def get_hostname(self) -> str:
+    async def get_hostname(self) -> str or None:
         if self.hostname:
             return self.hostname
         try:
@@ -42,10 +42,10 @@ class BTMiner(BaseMiner):
                 return self.hostname
         except APIError:
             logging.info(f"Failed to get hostname for miner: {self}")
-            return "?"
+            return None
         except Exception:
             logging.warning(f"Failed to get hostname for miner: {self}")
-            return "?"
+            return None
 
     async def get_board_info(self) -> dict:
         """Gets data on each board and chain in the miner."""
@@ -147,6 +147,9 @@ class BTMiner(BaseMiner):
                     if summary_data[0].get("MAC"):
                         mac = summary_data[0]["MAC"]
 
+                    if summary_data[0].get("Env Temp"):
+                        data.env_temp = summary_data[0]["Env Temp"]
+
                     data.fan_1 = summary_data[0]["Fan Speed In"]
                     data.fan_2 = summary_data[0]["Fan Speed Out"]
 

miners/_backends/cgminer.py

@@ -33,7 +33,7 @@ class CGMiner(BaseMiner):
             return self.model
         return None
 
-    async def get_hostname(self) -> str:
+    async def get_hostname(self) -> str or None:
         if self.hostname:
             return self.hostname
         try:
@@ -44,9 +44,9 @@ class CGMiner(BaseMiner):
                     self.hostname = host
                     return self.hostname
                 else:
-                    return "?"
+                    return None
         except Exception:
-            return "?"
+            return None
 
     async def send_ssh_command(self, cmd):
         result = None

miners/_types/avalonminer/A10X/A1026.py

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

miners/_types/avalonminer/A10X/A1047.py

@@ -6,5 +6,5 @@ class Avalon1047(BaseMiner):
         super().__init__()
         self.ip = ip
         self.model = "Avalon 1047"
-        self.nominal_chips = 114
-        self.fan_count = 4
+        self.nominal_chips = 80
+        self.fan_count = 2

miners/_types/avalonminer/A10X/__init__.py

@@ -1,2 +1,3 @@
+from .A1026 import Avalon1026
 from .A1047 import Avalon1047
 from .A1066 import Avalon1066

miners/_types/avalonminer/A7X/A721.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon721(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 721"
+        self.chip_count = 18  # This miner has 4 boards totaling 72
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A7X/A741.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon741(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 741"
+        self.chip_count = 22  # This miner has 4 boards totaling 88
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A7X/A761.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon761(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 761"
+        self.chip_count = 18  # This miner has 4 boards totaling 72
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A7X/__init__.py

@@ -0,0 +1,3 @@
+from .A721 import Avalon721
+from .A741 import Avalon741
+from .A761 import Avalon761

miners/_types/avalonminer/A8X/A821.py

@@ -6,4 +6,5 @@ class Avalon821(BaseMiner):
         super().__init__()
         self.ip = ip
         self.model = "Avalon 821"
-        self.fan_count = 2
+        self.chip_count = 26  # This miner has 4 boards totaling 104
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A8X/A841.py

@@ -6,4 +6,5 @@ class Avalon841(BaseMiner):
         super().__init__()
         self.ip = ip
         self.model = "Avalon 841"
-        self.fan_count = 2
+        self.chip_count = 26  # This miner has 4 boards totaling 104
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A8X/A851.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon851(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 851"
+        self.chip_count = 26  # This miner has 4 boards totaling 104
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A8X/__init__.py

@@ -1,2 +1,3 @@
 from .A821 import Avalon821
 from .A841 import Avalon841
+from .A851 import Avalon851

miners/_types/avalonminer/A9X/A921.py

@@ -0,0 +1,10 @@
+from miners import BaseMiner
+
+
+class Avalon921(BaseMiner):
+    def __init__(self, ip: str):
+        super().__init__()
+        self.ip = ip
+        self.model = "Avalon 921"
+        self.chip_count = 26  # This miner has 4 boards totaling 104
+        self.fan_count = 1  # also only 1 fan

miners/_types/avalonminer/A9X/__init__.py

@@ -0,0 +1 @@
+from .A921 import Avalon921

miners/_types/avalonminer/__init__.py

@@ -1,2 +1,4 @@
+from .A7X import *
 from .A8X import *
+from .A9X import *
 from .A10X import *

miners/antminer/bmminer/X17/S17.py

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

miners/antminer/bmminer/X17/S17_Plus.py

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

miners/antminer/bmminer/X17/S17_Pro.py

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

miners/antminer/bmminer/X17/S17e.py

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

miners/antminer/bmminer/X17/T17.py

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

miners/antminer/bmminer/X17/T17_Plus.py

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

miners/antminer/bmminer/X17/T17e.py

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

miners/antminer/bmminer/X17/X17.py

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

miners/antminer/bmminer/X19/S19.py

@@ -1,103 +1,8 @@
-from miners._backends import BMMiner  # noqa - Ignore access to _module
+from .X19 import BMMinerX19
 from miners._types import S19  # noqa - Ignore access to _module
 
-from config.miner_config import MinerConfig
 
-import httpx
-import json
-import asyncio
-
-
-class BMMinerS19(BMMiner, S19):
+class BMMinerS19(BMMinerX19, S19):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def get_config(self) -> MinerConfig:
-        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
-
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(url, data=conf, auth=auth)
-        except httpx.ReadTimeout:
-            pass
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def get_hostname(self) -> str or None:
-        hostname = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "hostname" in data.keys():
-                    hostname = data["hostname"]
-        return hostname
-
-    async def get_mac(self):
-        mac = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "macaddr" in data.keys():
-                    mac = data["macaddr"]
-        return mac
-
-    async def fault_light_on(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "true"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B000":
-                return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "false"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B100":
-                return True
-        return False
-
-    async def reboot(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            return True
-        return False

miners/antminer/bmminer/X19/S19_Pro.py

@@ -1,103 +1,8 @@
-from miners._backends import BMMiner  # noqa - Ignore access to _module
+from .X19 import BMMinerX19
 from miners._types import S19Pro  # noqa - Ignore access to _module
 
-from config.miner_config import MinerConfig
 
-import httpx
-import json
-import asyncio
-
-
-class BMMinerS19Pro(BMMiner, S19Pro):
+class BMMinerS19Pro(BMMinerX19, S19Pro):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def get_config(self) -> MinerConfig:
-        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
-
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(url, data=conf, auth=auth)
-        except httpx.ReadTimeout:
-            pass
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def get_hostname(self) -> str or None:
-        hostname = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "hostname" in data.keys():
-                    hostname = data["hostname"]
-        return hostname
-
-    async def get_mac(self):
-        mac = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "macaddr" in data.keys():
-                    mac = data["macaddr"]
-        return mac
-
-    async def fault_light_on(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "true"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B000":
-                return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "false"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B100":
-                return True
-        return False
-
-    async def reboot(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            return True
-        return False

miners/antminer/bmminer/X19/S19a.py

@@ -1,103 +1,8 @@
-from miners._backends import BMMiner  # noqa - Ignore access to _module
+from .X19 import BMMinerX19
 from miners._types import S19a  # noqa - Ignore access to _module
 
-from config.miner_config import MinerConfig
 
-import httpx
-import json
-import asyncio
-
-
-class BMMinerS19a(BMMiner, S19a):
+class BMMinerS19a(BMMinerX19, S19a):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def get_config(self) -> MinerConfig:
-        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
-
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(url, data=conf, auth=auth)
-        except httpx.ReadTimeout:
-            pass
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def get_hostname(self) -> str or None:
-        hostname = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "hostname" in data.keys():
-                    hostname = data["hostname"]
-        return hostname
-
-    async def get_mac(self):
-        mac = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "macaddr" in data.keys():
-                    mac = data["macaddr"]
-        return mac
-
-    async def fault_light_on(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "true"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B000":
-                return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "false"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B100":
-                return True
-        return False
-
-    async def reboot(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            return True
-        return False

miners/antminer/bmminer/X19/S19j.py

@@ -1,103 +1,8 @@
-from miners._backends import BMMiner  # noqa - Ignore access to _module
+from .X19 import BMMinerX19
 from miners._types import S19j  # noqa - Ignore access to _module
 
-from config.miner_config import MinerConfig
 
-import httpx
-import json
-import asyncio
-
-
-class BMMinerS19j(BMMiner, S19j):
+class BMMinerS19j(BMMinerX19, S19j):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def get_config(self) -> MinerConfig:
-        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
-
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(url, data=conf, auth=auth)
-        except httpx.ReadTimeout:
-            pass
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def get_hostname(self) -> str or None:
-        hostname = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "hostname" in data.keys():
-                    hostname = data["hostname"]
-        return hostname
-
-    async def get_mac(self):
-        mac = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "macaddr" in data.keys():
-                    mac = data["macaddr"]
-        return mac
-
-    async def fault_light_on(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "true"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B000":
-                return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "false"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B100":
-                return True
-        return False
-
-    async def reboot(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            return True
-        return False

miners/antminer/bmminer/X19/S19j_Pro.py

@@ -1,103 +1,8 @@
-from miners._backends import BMMiner  # noqa - Ignore access to _module
+from .X19 import BMMinerX19
 from miners._types import S19jPro  # noqa - Ignore access to _module
 
-from config.miner_config import MinerConfig
 
-import httpx
-import json
-import asyncio
-
-
-class BMMinerS19jPro(BMMiner, S19jPro):
+class BMMinerS19jPro(BMMinerX19, S19jPro):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def get_config(self) -> MinerConfig:
-        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
-
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(url, data=conf, auth=auth)
-        except httpx.ReadTimeout:
-            pass
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def get_hostname(self) -> str or None:
-        hostname = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "hostname" in data.keys():
-                    hostname = data["hostname"]
-        return hostname
-
-    async def get_mac(self):
-        mac = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "macaddr" in data.keys():
-                    mac = data["macaddr"]
-        return mac
-
-    async def fault_light_on(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "true"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B000":
-                return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "false"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B100":
-                return True
-        return False
-
-    async def reboot(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            return True
-        return False

miners/antminer/bmminer/X19/T19.py

@@ -1,103 +1,8 @@
-from miners._backends import BMMiner  # noqa - Ignore access to _module
+from .X19 import BMMinerX19
 from miners._types import T19  # noqa - Ignore access to _module
 
-from config.miner_config import MinerConfig
 
-import httpx
-import json
-import asyncio
-
-
-class BMMinerT19(BMMiner, T19):
+class BMMinerT19(BMMinerX19, T19):
     def __init__(self, ip: str) -> None:
         super().__init__(ip)
         self.ip = ip
-
-    async def get_config(self) -> MinerConfig:
-        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
-        else:
-            conf = MinerConfig().from_yaml(yaml_config).as_x19()
-
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(url, data=conf, auth=auth)
-        except httpx.ReadTimeout:
-            pass
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def get_hostname(self) -> str or None:
-        hostname = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "hostname" in data.keys():
-                    hostname = data["hostname"]
-        return hostname
-
-    async def get_mac(self):
-        mac = None
-        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if len(data.keys()) > 0:
-                if "macaddr" in data.keys():
-                    mac = data["macaddr"]
-        return mac
-
-    async def fault_light_on(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "true"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B000":
-                return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/blink.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        data = json.dumps({"blink": "false"})
-        async with httpx.AsyncClient() as client:
-            data = await client.post(url, data=data, auth=auth)
-        if data.status_code == 200:
-            data = data.json()
-            if data.get("code") == "B100":
-                return True
-        return False
-
-    async def reboot(self) -> bool:
-        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
-        auth = httpx.DigestAuth("root", "root")
-        async with httpx.AsyncClient() as client:
-            data = await client.get(url, auth=auth)
-        if data.status_code == 200:
-            return True
-        return False

miners/antminer/bmminer/X19/X19.py

@@ -0,0 +1,102 @@
+from miners._backends import BMMiner  # noqa - Ignore access to _module
+
+from config import MinerConfig
+
+import httpx
+import json
+import asyncio
+
+
+class BMMinerX19(BMMiner):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.ip = ip
+
+    async def get_config(self) -> MinerConfig:
+        url = f"http://{self.ip}/cgi-bin/get_miner_conf.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            self.config = MinerConfig().from_raw(data)
+        return self.config
+
+    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
+        url = f"http://{self.ip}/cgi-bin/set_miner_conf.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        if ip_user:
+            suffix = str(self.ip).split(".")[-1]
+            conf = MinerConfig().from_yaml(yaml_config).as_x19(user_suffix=suffix)
+        else:
+            conf = MinerConfig().from_yaml(yaml_config).as_x19()
+
+        try:
+            async with httpx.AsyncClient() as client:
+                await client.post(url, data=conf, auth=auth)
+        except httpx.ReadTimeout:
+            pass
+        for i in range(7):
+            data = await self.get_config()
+            if data.as_x19() == conf:
+                break
+            await asyncio.sleep(1)
+
+    async def get_hostname(self) -> str or None:
+        hostname = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "hostname" in data.keys():
+                    hostname = data["hostname"]
+        return hostname
+
+    async def get_mac(self):
+        mac = None
+        url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if len(data.keys()) > 0:
+                if "macaddr" in data.keys():
+                    mac = data["macaddr"]
+        return mac
+
+    async def fault_light_on(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        data = json.dumps({"blink": "true"})
+        async with httpx.AsyncClient() as client:
+            data = await client.post(url, data=data, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data.get("code") == "B000":
+                return True
+        return False
+
+    async def fault_light_off(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/blink.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        data = json.dumps({"blink": "false"})
+        async with httpx.AsyncClient() as client:
+            data = await client.post(url, data=data, auth=auth)
+        if data.status_code == 200:
+            data = data.json()
+            if data.get("code") == "B100":
+                return True
+        return False
+
+    async def reboot(self) -> bool:
+        url = f"http://{self.ip}/cgi-bin/reboot.cgi"
+        auth = httpx.DigestAuth("root", "root")
+        async with httpx.AsyncClient() as client:
+            data = await client.get(url, auth=auth)
+        if data.status_code == 200:
+            return True
+        return False

miners/avalonminer/cgminer/A10X/A1026.py

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

miners/avalonminer/cgminer/A10X/A1047.py

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

miners/avalonminer/cgminer/A10X/A1066.py

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

miners/avalonminer/cgminer/A10X/__init__.py

@@ -1,2 +1,3 @@
+from .A1026 import CGMinerAvalon1026
 from .A1047 import CGMinerAvalon1047
 from .A1066 import CGMinerAvalon1066

miners/avalonminer/cgminer/A7X/A721.py

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

miners/avalonminer/cgminer/A7X/A741.py

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

miners/avalonminer/cgminer/A7X/A761.py

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

miners/avalonminer/cgminer/A7X/__init__.py

@@ -0,0 +1,3 @@
+from .A721 import CGMinerAvalon721
+from .A741 import CGMinerAvalon741
+from .A761 import CGMinerAvalon761

miners/avalonminer/cgminer/A8X/A821.py

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

miners/avalonminer/cgminer/A8X/A841.py

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

miners/avalonminer/cgminer/A8X/A851.py

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

miners/avalonminer/cgminer/A8X/__init__.py

@@ -1,2 +1,3 @@
 from .A821 import CGMinerAvalon821
 from .A841 import CGMinerAvalon841
+from .A851 import CGMinerAvalon851

miners/avalonminer/cgminer/A9X/A921.py

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

miners/avalonminer/cgminer/A9X/__init__.py

@@ -0,0 +1 @@
+from .A921 import CGMinerAvalon921

miners/avalonminer/cgminer/__init__.py

@@ -1,2 +1,4 @@
+from .A7X import *
 from .A8X import *
+from .A9X import *
 from .A10X import *

miners/miner_factory.py

@@ -176,6 +176,46 @@ MINER_CLASSES = {
         "Default": BTMinerM32S,
         "BTMiner": BTMinerM32S,
     },
+    "AvalonMiner 721": {
+        "Default": CGMinerAvalon721,
+        "CGMiner": CGMinerAvalon721,
+    },
+    "AvalonMiner 741": {
+        "Default": CGMinerAvalon741,
+        "CGMiner": CGMinerAvalon741,
+    },
+    "AvalonMiner 761": {
+        "Default": CGMinerAvalon761,
+        "CGMiner": CGMinerAvalon761,
+    },
+    "AvalonMiner 821": {
+        "Default": CGMinerAvalon821,
+        "CGMiner": CGMinerAvalon821,
+    },
+    "AvalonMiner 841": {
+        "Default": CGMinerAvalon841,
+        "CGMiner": CGMinerAvalon841,
+    },
+    "AvalonMiner 851": {
+        "Default": CGMinerAvalon851,
+        "CGMiner": CGMinerAvalon851,
+    },
+    "AvalonMiner 921": {
+        "Default": CGMinerAvalon921,
+        "CGMiner": CGMinerAvalon921,
+    },
+    "AvalonMiner 1026": {
+        "Default": CGMinerAvalon1026,
+        "CGMiner": CGMinerAvalon1026,
+    },
+    "AvalonMiner 1047": {
+        "Default": CGMinerAvalon1047,
+        "CGMiner": CGMinerAvalon1047,
+    },
+    "AvalonMiner 1066": {
+        "Default": CGMinerAvalon1066,
+        "CGMiner": CGMinerAvalon1066,
+    },
 }
 
 
@@ -256,22 +296,21 @@ class MinerFactory(metaclass=Singleton):
             if not api:
                 api = "Default"
 
-            # Avalonminers
-            if "avalon" in model:
-                if model == "avalon10":
-                    miner = CGMinerAvalon1066(str(ip))
-                else:
-                    miner = CGMinerAvalon821(str(ip))
-            else:
-                if model not in MINER_CLASSES.keys():
-                    miner = UnknownMiner(str(ip))
-                    return miner
-                if api not in MINER_CLASSES[model].keys():
-                    api = "Default"
-                if ver in MINER_CLASSES[model].keys():
-                    miner = MINER_CLASSES[model][ver](str(ip))
-                    return miner
-                miner = MINER_CLASSES[model][api](str(ip))
+            if model not in MINER_CLASSES.keys():
+                if "avalon" in model:
+                    print(model)
+                    if model == "avalon10":
+                        miner = CGMinerAvalon1066(str(ip))
+                    else:
+                        miner = CGMinerAvalon821(str(ip))
+                miner = UnknownMiner(str(ip))
+                return miner
+            if api not in MINER_CLASSES[model].keys():
+                api = "Default"
+            if ver in MINER_CLASSES[model].keys():
+                miner = MINER_CLASSES[model][ver](str(ip))
+                return miner
+            miner = MINER_CLASSES[model][api](str(ip))
 
         # if we cant find a model, check if we found the API
         else:
@@ -407,6 +446,18 @@ class MinerFactory(metaclass=Singleton):
             ):
                 api = "BTMiner"
 
+            # check for avalonminers
+            if version["VERSION"][0].get("PROD"):
+                _data = version["VERSION"][0]["PROD"].split("-")
+                model = _data[0]
+                if len(data) > 1:
+                    ver = _data[1]
+            elif version["VERSION"][0].get("MODEL"):
+                _data = version["VERSION"][0]["MODEL"].split("-")
+                model = f"AvalonMiner {_data[0]}"
+                if len(data) > 1:
+                    ver = _data[1]
+
         # if we have no model from devdetails but have version, try to get it from there
         if version and not model:
             # make sure version isn't blank

settings/__init__.py

@@ -13,17 +13,19 @@ MINER_FACTORY_GET_VERSION_RETRIES: int = 3
 WHATSMINER_PWD = "admin"
 
 DEBUG = False
+LOGFILE = False
+
+settings_keys = {}
 
 try:
     with open(
         os.path.join(os.path.dirname(__file__), "settings.toml"), "r"
     ) as settings_file:
         settings = toml.loads(settings_file.read())
+    settings_keys = settings.keys()
 except:
     pass
 
-settings_keys = settings.keys()
-
 if "ping_retries" in settings_keys:
     NETWORK_PING_RETRIES: int = settings["ping_retries"]
 if "ping_timeout" in settings_keys:
@@ -46,3 +48,6 @@ if "whatsminer_pwd" in settings_keys:
 
 if "debug" in settings_keys:
     DEBUG: int = settings["debug"]
+
+if "logfile" in settings_keys:
+    LOGFILE: bool = settings["logfile"]

settings/settings.toml

@@ -13,6 +13,8 @@ reboot_threads = 300
 
 whatsminer_pwd = "admin"
 
+logfile = true
+
 ### DEBUG MODE ###
 # change this to debug = true
 # to enable debug mode.

tools/cfg_util/boards/__init__.py

@@ -2,6 +2,7 @@ import datetime
 import ipaddress
 from base64 import b64decode
 from io import BytesIO
+from copy import copy
 
 import matplotlib.pyplot as plt
 from matplotlib.figure import Figure
@@ -178,15 +179,26 @@ def create_boards_pie_chart(data):
     num_bad_boards = [0, 0, 0, 0]
     for item in data.keys():
         num_bad_boards[len(data[item])] += 1
+    idxs = []
+    graph_labels = copy(labels)
+    graph_num_bad_board = copy(num_bad_boards)
+    for idx in range(len(num_bad_boards)):
+        if num_bad_boards[idx] == 0:
+            idxs.append(idx)
+        idxs.sort(reverse=True)
+    for idx in idxs:
+        graph_labels.pop(idx)
+        graph_num_bad_board.pop(idx)
+
     cmap = plt.get_cmap("Blues")
-    cs = cmap(np.linspace(0.2, 0.8, num=len(num_bad_boards)))
+    cs = cmap(np.linspace(0.2, 0.8, num=len(graph_num_bad_board)))
 
     # fig, ax = plt.subplots() -> causes window resizing...
     fig = Figure()
     ax = fig.add_subplot()
     ax.pie(
-        num_bad_boards,
-        labels=labels,
+        graph_num_bad_board,
+        labels=graph_labels,
         autopct="%1.2f%%",
         shadow=True,
         startangle=180,

tools/cfg_util/configure/__init__.py

@@ -1,13 +1,13 @@
-import PySimpleGUI as sg
-from config.bos import bos_config_convert
-import time
-from tools.cfg_util.layout import window, update_prog_bar
-from tools.cfg_util.decorators import disable_buttons
-from miners.miner_factory import MinerFactory
 import asyncio
-from settings import CFG_UTIL_CONFIG_THREADS as CONFIG_THREADS
-from tools.cfg_util.general import update_miners_data
 
+import PySimpleGUI as sg
+
+from config import MinerConfig
+from miners.miner_factory import MinerFactory
+from settings import CFG_UTIL_CONFIG_THREADS as CONFIG_THREADS
+from tools.cfg_util.decorators import disable_buttons
+from tools.cfg_util.general import update_miners_data
+from tools.cfg_util.layout import window, update_prog_bar
 
 progress_bar_len = 0
 
@@ -68,7 +68,25 @@ async def send_config_generator(miners: list, config, last_octet_ip_user: bool):
         yield await sent_config
 
 
-def generate_config(username: str, workername: str, v2_allowed: bool):
+def generate_config(
+    username: str,
+    workername: str,
+    v2_allowed: bool,
+    advanced_cfg: bool,
+    autotuning_enabled: bool,
+    autotuning_wattage: int,
+    manual_fan_control: bool,
+    manual_fan_speed: int,
+    min_fans: int,
+    target_temp: int,
+    hot_temp: int,
+    dangerous_temp: int,
+    dps_enabled: bool,
+    dps_power_step: int,
+    dps_min_power: int,
+    dps_shutdown_enabled: bool,
+    dps_shutdown_duration: int,
+):
     if username and workername:
         user = f"{username}.{workername}"
     elif username and not workername:
@@ -84,33 +102,67 @@ def generate_config(username: str, workername: str, v2_allowed: bool):
         url_1 = "stratum+tcp://ca.stratum.slushpool.com:3333"
         url_2 = "stratum+tcp://us-east.stratum.slushpool.com:3333"
         url_3 = "stratum+tcp://stratum.slushpool.com:3333"
-
-    config = {
-        "group": [
-            {
-                "name": "group",
-                "quota": 1,
-                "pool": [
-                    {"url": url_1, "user": user, "password": "123"},
-                    {"url": url_2, "user": user, "password": "123"},
-                    {"url": url_3, "user": user, "password": "123"},
-                ],
+    if not advanced_cfg:
+        config = {
+            "group": [
+                {
+                    "name": "group",
+                    "quota": 1,
+                    "pool": [
+                        {"url": url_1, "user": user, "password": "123"},
+                        {"url": url_2, "user": user, "password": "123"},
+                        {"url": url_3, "user": user, "password": "123"},
+                    ],
+                }
+            ],
+            "temp_control": {
+                "target_temp": 80.0,
+                "hot_temp": 90.0,
+                "dangerous_temp": 120.0,
+            },
+            "autotuning": {"enabled": True, "psu_power_limit": 900},
+        }
+    else:
+        config = {
+            "group": [
+                {
+                    "name": "group",
+                    "quota": 1,
+                    "pool": [
+                        {"url": url_1, "user": user, "password": "123"},
+                        {"url": url_2, "user": user, "password": "123"},
+                        {"url": url_3, "user": user, "password": "123"},
+                    ],
+                }
+            ],
+            "temp_control": {
+                "mode": "auto",
+                "target_temp": float(target_temp),
+                "hot_temp": float(hot_temp),
+                "dangerous_temp": float(dangerous_temp),
+            },
+            "autotuning": {
+                "enabled": autotuning_enabled,
+                "psu_power_limit": autotuning_wattage,
+            },
+        }
+        if manual_fan_control:
+            config["temp_control"]["mode"] = "manual"
+            config["fan_control"] = {}
+            config["fan_control"]["speed"] = manual_fan_speed
+            config["fan_control"]["min_fans"] = min_fans
+        if dps_enabled:
+            config["power_scaling"] = {
+                "enabled": dps_enabled,
+                "power_step": dps_power_step,
+                "min_psu_power_limit": dps_min_power,
+                "shutdown_enabled": dps_shutdown_enabled,
+                "shutdown_duration": dps_shutdown_duration,
             }
-        ],
-        "format": {
-            "version": "1.2+",
-            "model": "Antminer S9",
-            "generator": "upstream_config_util",
-            "timestamp": int(time.time()),
-        },
-        "temp_control": {
-            "target_temp": 80.0,
-            "hot_temp": 90.0,
-            "dangerous_temp": 120.0,
-        },
-        "autotuning": {"enabled": True, "psu_power_limit": 900},
-    }
-    window["cfg_config_txt"].update(bos_config_convert(config))
+
+    cfg = MinerConfig().from_raw(config)
+
+    window["cfg_config_txt"].update(cfg.as_yaml())
 
 
 async def generate_config_ui():
@@ -127,9 +179,51 @@ async def generate_config_ui():
                     values["generate_config_window_username"],
                     values["generate_config_window_workername"],
                     values["generate_config_window_allow_v2"],
+                    values["show_advanced_options"],
+                    values["autotuning_enabled"],
+                    values["autotuning_wattage"],
+                    values["manual_fan_control"],
+                    values["manual_fan_speed"],
+                    values["min_fans"],
+                    values["target_temp"],
+                    values["hot_temp"],
+                    values["danger_temp"],
+                    values["dps_enabled"],
+                    values["dps_power_step"],
+                    values["dps_min_power"],
+                    values["dps_shutdown_enabled"],
+                    values["dps_shutdown_duration"],
                 )
                 generate_config_window.close()
                 break
+        if event == "show_advanced_options":
+            generate_config_window["advanced_options"].update(
+                visible=values["show_advanced_options"]
+            )
+
+        if event == "autotuning_enabled":
+            generate_config_window["autotuning_wattage"].update(
+                disabled=not values["autotuning_enabled"]
+            )
+        if event == "manual_fan_control":
+            generate_config_window["manual_fan_speed"].update(
+                disabled=not values["manual_fan_control"]
+            )
+            generate_config_window["min_fans"].update(
+                disabled=not values["manual_fan_control"]
+            )
+        if event == "dps_enabled":
+            for elem in ["dps_power_step", "dps_min_power", "dps_shutdown_enabled"]:
+                generate_config_window[elem].update(disabled=not values["dps_enabled"])
+            if not values["dps_enabled"]:
+                generate_config_window["dps_shutdown_duration"].update(disabled=True)
+            if values["dps_enabled"] and values["dps_shutdown_enabled"]:
+                generate_config_window["dps_shutdown_duration"].update(disabled=False)
+        if event == "dps_shutdown_enabled":
+            if values["dps_enabled"]:
+                generate_config_window["dps_shutdown_duration"].update(
+                    disabled=not values["dps_shutdown_enabled"]
+                )
 
 
 def generate_config_layout():
@@ -156,6 +250,123 @@ def generate_config_layout():
             sg.Text("Allow Stratum V2?:", size=(19, 1)),
             sg.Checkbox("", key="generate_config_window_allow_v2", default=True),
         ],
+        [
+            sg.Push(),
+            sg.Checkbox(
+                "Advanced Options", enable_events=True, key="show_advanced_options"
+            ),
+        ],
+        [
+            sg.pin(
+                sg.Column(
+                    [
+                        [
+                            sg.Text("Autotuning Enabled:", size=(19, 1)),
+                            sg.Checkbox(
+                                "", key="autotuning_enabled", enable_events=True
+                            ),
+                            sg.Text("Power Limit:"),
+                            sg.Spin(
+                                [i for i in range(100, 5001, 100)],
+                                initial_value=900,
+                                size=(5, 1),
+                                key="autotuning_wattage",
+                                disabled=True,
+                            ),
+                        ],
+                        [
+                            sg.Text("Manual Fan Control:", size=(19, 1)),
+                            sg.Checkbox(
+                                "", key="manual_fan_control", enable_events=True
+                            ),
+                            sg.Text("Speed:"),
+                            sg.Spin(
+                                [i for i in range(5, 101, 5)],
+                                initial_value=100,
+                                size=(5, 1),
+                                key="manual_fan_speed",
+                                disabled=True,
+                            ),
+                            sg.Text("Min Fans:"),
+                            sg.Spin(
+                                [i for i in range(5)],
+                                initial_value=1,
+                                size=(5, 1),
+                                key="min_fans",
+                                disabled=True,
+                            ),
+                        ],
+                        [
+                            sg.Text("Target Temp:", size=(19, 1)),
+                            sg.Spin(
+                                [i for i in range(5, 101, 5)],
+                                initial_value=80,
+                                size=(5, 1),
+                                key="target_temp",
+                            ),
+                        ],
+                        [
+                            sg.Text("Hot Temp:", size=(19, 1)),
+                            sg.Spin(
+                                [i for i in range(5, 111, 5)],
+                                initial_value=90,
+                                size=(5, 1),
+                                key="hot_temp",
+                            ),
+                        ],
+                        [
+                            sg.Text("Dangerous Temp:", size=(19, 1)),
+                            sg.Spin(
+                                [i for i in range(5, 131, 5)],
+                                initial_value=100,
+                                size=(5, 1),
+                                key="danger_temp",
+                            ),
+                        ],
+                        [
+                            sg.Text("Dynamic Power Scaling:"),
+                            sg.Checkbox("", key="dps_enabled", enable_events=True),
+                            sg.Text("Power Step:"),
+                            sg.Spin(
+                                [i for i in range(50, 301, 5)],
+                                initial_value=100,
+                                size=(5, 1),
+                                key="dps_power_step",
+                                disabled=True,
+                            ),
+                            sg.Text("Min Power:"),
+                            sg.Spin(
+                                [i for i in range(100, 5001, 100)],
+                                initial_value=800,
+                                size=(5, 1),
+                                key="dps_min_power",
+                                disabled=True,
+                            ),
+                        ],
+                        [
+                            sg.Text("DPS Shutdown:"),
+                            sg.Checkbox(
+                                "",
+                                key="dps_shutdown_enabled",
+                                enable_events=True,
+                                disabled=True,
+                            ),
+                            sg.Text("Shutdown Duration (H):"),
+                            sg.Spin(
+                                [i for i in range(1, 11, 1)],
+                                initial_value=3,
+                                size=(5, 1),
+                                key="dps_shutdown_duration",
+                                disabled=True,
+                            ),
+                        ],
+                    ],
+                    key="advanced_options",
+                    visible=False,
+                    pad=0,
+                )
+            )
+        ],
         [sg.Button("Generate", key="generate_config_window_generate")],
     ]
     return config_layout

tools/web_testbench/feeds.py

@@ -1,12 +1,12 @@
-import aiohttp
-import httpx
-import shutil
-import aiofiles
 import asyncio
-from bs4 import BeautifulSoup
-import re
-import os
 import logging
+import os
+import re
+import shutil
+
+import aiofiles
+import httpx
+from bs4 import BeautifulSoup
 
 
 async def get_latest_version(session):