version: bump version number.

docs/API/api.md

@@ -10,6 +10,7 @@ All API implementations inherit from [`BaseMinerAPI`][pyasic.API.BaseMinerAPI],
 [`BaseMinerAPI`][pyasic.API.BaseMinerAPI] cannot be instantiated directly, it will raise a `TypeError`.
 Use these instead -
 
+#### [BFGMiner API][pyasic.API.bfgminer.BFGMinerAPI]
 #### [BMMiner API][pyasic.API.bmminer.BMMinerAPI]
 #### [BOSMiner API][pyasic.API.bosminer.BOSMinerAPI]
 #### [BTMiner API][pyasic.API.btminer.BTMinerAPI]

docs/API/bfgminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## BFGMinerAPI
+::: pyasic.API.bfgminer.BFGMinerAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/index.md

@@ -42,21 +42,27 @@ if __name__ == "__main__":
 <br>
 
 ## Creating miners based on IP
-If you already know the IP address of your miner or miners, you can use the [`MinerFactory`][pyasic.miners.miner_factory.MinerFactory] to communicate and identify the miners.
+If you already know the IP address of your miner or miners, you can use the [`MinerFactory`][pyasic.miners.miner_factory.MinerFactory] to communicate and identify the miners, or an abstraction of its functionality, [`get_miner()`][pyasic.miners.miner_factory.MinerFactory.get_miner].
-The function [`MinerFactory().get_miner()`][pyasic.miners.miner_factory.MinerFactory.get_miner] will return any miner it found at the IP address specified, or an `UnknownMiner` if it cannot identify the miner.
+The function [`get_miner()`][pyasic.miners.miner_factory.MinerFactory.get_miner] will return any miner it found at the IP address specified, or an `UnknownMiner` if it cannot identify the miner.
 ```python
 import asyncio  # asyncio for handling the async part
-from pyasic.miners.miner_factory import MinerFactory  # miner factory handles miners creation
+from pyasic import get_miner # handles miner creation
 
 
 async def get_miners():  # define async scan function to allow awaiting
-    # get the miner with miner factory
+    # get the miner with the miner factory
-    # miner factory is a singleton, and will always use the same object and cache
+    # the miner factory is a singleton, and will always use the same object and cache
-    # this means you can always call it as MinerFactory().get_miner()
+    # this means you can always call it as MinerFactory().get_miner(), or just get_miner()
-    miner_1 = await MinerFactory().get_miner("192.168.1.75")
+    miner_1 = await get_miner("192.168.1.75")
-    miner_2 = await MinerFactory().get_miner("192.168.1.76")
+    miner_2 = await get_miner("192.168.1.76")
     print(miner_1, miner_2)
 
+    # can also gather these, since they are async
+    tasks = [get_miner("192.168.1.75"), get_miner("192.168.1.76")]
+    miners = await asyncio.gather(*tasks)
+    print(miners)
+
+
 if __name__ == "__main__":
     asyncio.run(get_miners())  # get the miners asynchronously with asyncio.run()
 ```
@@ -66,7 +72,7 @@ if __name__ == "__main__":
 ## Getting data from miners
 
 Once you have your miner(s) identified, you will likely want to get data from the miner(s).  You can do this using a built in function in each miner called `get_data()`.
-This function will return a instance of the dataclass [`MinerData`][pyasic.data.MinerData] with all data it can gather from the miner.
+This function will return an instance of the dataclass [`MinerData`][pyasic.data.MinerData] with all data it can gather from the miner.
 Each piece of data in a [`MinerData`][pyasic.data.MinerData] instance can be referenced by getting it as an attribute, such as [`MinerData().hashrate`][pyasic.data.MinerData].
 ```python
 import asyncio

docs/miners/backends/bfgminer.md

@@ -1,7 +1,7 @@
 # pyasic
 ## BFGMiner Backend
 
-::: pyasic.miners.kda._backends.bfgminer.BFGMiner
+::: pyasic.miners.backends.bfgminer.BFGMiner
     handler: python
     options:
         show_root_heading: false

docs/miners/backends/bmminer.md

@@ -1,7 +1,7 @@
 # pyasic
 ## BMMiner Backend
 
-::: pyasic.miners.btc._backends.bmminer.BMMiner
+::: pyasic.miners.backends.bmminer.BMMiner
     handler: python
     options:
         show_root_heading: false

docs/miners/backends/bosminer.md

@@ -1,7 +1,7 @@
 # pyasic
 ## BOSMiner Backend
 
-::: pyasic.miners.btc._backends.bosminer.BOSMiner
+::: pyasic.miners.backends.bosminer.BOSMiner
     handler: python
     options:
         show_root_heading: false

docs/miners/backends/btminer.md

@@ -1,7 +1,7 @@
 # pyasic
 ## BTMiner Backend
 
-::: pyasic.miners.btc._backends.btminer.BTMiner
+::: pyasic.miners.backends.btminer.BTMiner
     handler: python
     options:
         show_root_heading: false

docs/miners/backends/cgminer.md

@@ -1,7 +1,7 @@
 # pyasic
 ## CGMiner Backend
 
-::: pyasic.miners.btc._backends.cgminer.CGMiner
+::: pyasic.miners.backends.cgminer.CGMiner
     handler: python
     options:
         show_root_heading: false

docs/miners/backends/hiveon.md

@@ -1,7 +1,7 @@
 # pyasic
 ## Hiveon Backend
 
-::: pyasic.miners.btc._backends.hiveon.Hiveon
+::: pyasic.miners.backends.hiveon.Hiveon
     handler: python
     options:
         show_root_heading: false

docs/miners/supported_types.md

@@ -541,7 +541,7 @@ details {
     </ul>
 </details>
 <details>
-<summary>Stock Firmware Goldshell Miners:</summary>
+<summary>Stock Firmware BFGMinerGoldshell Miners:</summary>
     <ul>
         <details>
         <summary>CKX Series:</summary>

mkdocs.yml

@@ -1,54 +1,54 @@
 site_name: pyasic
 repo_url: https://github.com/UpstreamData/pyasic
 nav:
-  - Introduction: "index.md"
+- Introduction: "index.md"
-  - Miners:
+- Miners:
-      - Supported Miners: "miners/supported_types.md"
+    - Supported Miners: "miners/supported_types.md"
-      - Miner Factory: "miners/miner_factory.md"
+    - Miner Factory: "miners/miner_factory.md"
-      - Backends:
+- Network:
-          - BMMiner: "miners/backends/bmminer.md"
+    - Miner Network: "network/miner_network.md"
-          - BOSMiner: "miners/backends/bosminer.md"
+    - Miner Network Range: "network/miner_network_range.md"
-          - BFGMiner: "miners/backends/bfgminer.md"
+- Dataclasses:
-          - BTMiner: "miners/backends/btminer.md"
+    - Miner Data: "data/miner_data.md"
-          - CGMiner: "miners/backends/cgminer.md"
+    - Error Codes: "data/error_codes.md"
-          - Hiveon: "miners/backends/hiveon.md"
+    - Miner Config: "config/miner_config.md"
-      - Classes:
+- Advanced:
-          - Antminer X3: "miners/antminer/X3.md"
+    - Miner APIs:
-          - Antminer X5: "miners/antminer/X5.md"
+        - Intro: "API/api.md"
-          - Antminer X7: "miners/antminer/X7.md"
+        - BFGMiner: "API/bfgminer.md"
-          - Antminer X9: "miners/antminer/X9.md"
+        - BMMiner: "API/bmminer.md"
-          - Antminer X15: "miners/antminer/X15.md"
+        - BOSMiner: "API/bosminer.md"
-          - Antminer X17: "miners/antminer/X17.md"
+        - BTMiner: "API/btminer.md"
-          - Antminer X19: "miners/antminer/X19.md"
+        - CGMiner: "API/cgminer.md"
-          - Avalon 7X: "miners/avalonminer/A7X.md"
+        - Unknown: "API/unknown.md"
-          - Avalon 8X: "miners/avalonminer/A8X.md"
+    - Backends:
-          - Avalon 9X: "miners/avalonminer/A9X.md"
+        - BMMiner: "miners/backends/bmminer.md"
-          - Avalon 10X: "miners/avalonminer/A10X.md"
+        - BOSMiner: "miners/backends/bosminer.md"
-          - Whatsminer M2X: "miners/whatsminer/M2X.md"
+        - BFGMiner: "miners/backends/bfgminer.md"
-          - Whatsminer M3X: "miners/whatsminer/M3X.md"
+        - BTMiner: "miners/backends/btminer.md"
-          - Whatsminer M5X: "miners/whatsminer/M5X.md"
+        - CGMiner: "miners/backends/cgminer.md"
-          - Innosilicon T3X: "miners/innosilicon/T3X.md"
+        - Hiveon: "miners/backends/hiveon.md"
-          - Innosilicon A10X: "miners/innosilicon/A10X.md"
+    - Classes:
-          - Goldshell CKX: "miners/goldshell/CKX.md"
+        - Antminer X3: "miners/antminer/X3.md"
-          - Goldshell HSX: "miners/goldshell/HSX.md"
+        - Antminer X5: "miners/antminer/X5.md"
-          - Goldshell KDX: "miners/goldshell/KDX.md"
+        - Antminer X7: "miners/antminer/X7.md"
-  - Network:
+        - Antminer X9: "miners/antminer/X9.md"
-      - Miner Network: "network/miner_network.md"
+        - Antminer X15: "miners/antminer/X15.md"
-      - Miner Network Range: "network/miner_network_range.md"
+        - Antminer X17: "miners/antminer/X17.md"
-  - Dataclasses:
+        - Antminer X19: "miners/antminer/X19.md"
-      - Miner Data: "data/miner_data.md"
+        - Avalon 7X: "miners/avalonminer/A7X.md"
-      - Error Codes: "data/error_codes.md"
+        - Avalon 8X: "miners/avalonminer/A8X.md"
-      - Miner Config: "config/miner_config.md"
+        - Avalon 9X: "miners/avalonminer/A9X.md"
-  - Advanced:
+        - Avalon 10X: "miners/avalonminer/A10X.md"
-      - Miner APIs:
+        - Whatsminer M2X: "miners/whatsminer/M2X.md"
-          - Intro: "API/api.md"
+        - Whatsminer M3X: "miners/whatsminer/M3X.md"
-          - BMMiner: "API/bmminer.md"
+        - Whatsminer M5X: "miners/whatsminer/M5X.md"
-          - BOSMiner: "API/bosminer.md"
+        - Innosilicon T3X: "miners/innosilicon/T3X.md"
-          - BTMiner: "API/btminer.md"
+        - Innosilicon A10X: "miners/innosilicon/A10X.md"
-          - CGMiner: "API/cgminer.md"
+        - Goldshell CKX: "miners/goldshell/CKX.md"
-          - Unknown: "API/unknown.md"
+        - Goldshell HSX: "miners/goldshell/HSX.md"
-
+        - Goldshell KDX: "miners/goldshell/KDX.md"
-      - Base Miner: "miners/base_miner.md"
+    - Base Miner: "miners/base_miner.md"
 
 
 plugins:

pyasic/API/__init__.py

@@ -92,9 +92,7 @@ class BaseMinerAPI:
     async def send_privileged_command(self, *args, **kwargs) -> dict:
         return await self.send_command(*args, **kwargs)
 
-    async def multicommand(
+    async def multicommand(self, *commands: str, allow_warning: bool = True) -> dict:
-        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
-    ) -> dict:
         """Creates and sends multiple commands as one command to the miner.
 
         Parameters:
@@ -103,19 +101,25 @@ class BaseMinerAPI:
             allow_warning: A boolean to supress APIWarnings.
 
         """
-        # make sure we can actually run each command, otherwise they will fail
+        while True:
-        commands = self._check_commands(*commands)
+            # make sure we can actually run each command, otherwise they will fail
-        # standard multicommand format is "command1+command2"
+            commands = self._check_commands(*commands)
-        # standard format doesn't work for X19
+            # standard multicommand format is "command1+command2"
-        command = "+".join(commands)
+            # standard format doesn't work for X19
-        try:
+            command = "+".join(commands)
-            data = await self.send_command(
+            try:
-                command, allow_warning=allow_warning, ignore_errors=ignore_errors
+                data = await self.send_command(command, allow_warning=allow_warning)
-            )
+            except APIError as e:
-        except APIError:
+                # try to identify the error
-            return {command: [{}] for command in commands}
+                if ":" in e.message:
-        logging.debug(f"{self} - (Multicommand) - Received data")
+                    err_command = e.message.split(":")[0]
-        return data
+                    if err_command in commands:
+                        commands.remove(err_command)
+                        continue
+                return {command: [{}] for command in commands}
+            logging.debug(f"{self} - (Multicommand) - Received data")
+            data["multicommand"] = True
+            return data
 
     @property
     def commands(self) -> list:

pyasic/API/bfgminer.py

@@ -52,9 +52,10 @@ class BFGMinerAPI(BaseMinerAPI):
         except APIError:
             logging.debug(f"{self} - (Multicommand) - Handling X19 multicommand.")
             data = await self._x19_multicommand(*command.split("+"))
+        data["multicommand"] = True
         return data
 
-    async def _x19_multicommand(self, *commands):
+    async def _x19_multicommand(self, *commands) -> dict:
         data = None
         try:
             data = {}

pyasic/API/bmminer.py

@@ -53,9 +53,10 @@ class BMMinerAPI(BaseMinerAPI):
             data = await self._x19_multicommand(
                 *command.split("+"), allow_warning=allow_warning
             )
+        data["multicommand"] = True
         return data
 
-    async def _x19_multicommand(self, *commands, allow_warning: bool = True):
+    async def _x19_multicommand(self, *commands, allow_warning: bool = True) -> dict:
         data = None
         try:
             data = {}

pyasic/API/btminer.py

@@ -224,6 +224,7 @@ class BTMinerAPI(BaseMinerAPI):
         logging.debug(f"{self} - (Multicommand) - Received data")
 
         data = dict(**main_data, **get_commands_data)
+        data["multicommand"] = True
         return data
 
     async def send_privileged_command(

pyasic/API/cgminer.py

@@ -52,9 +52,10 @@ class CGMinerAPI(BaseMinerAPI):
         except APIError:
             logging.debug(f"{self} - (Multicommand) - Handling X19 multicommand.")
             data = await self._x19_multicommand(*command.split("+"))
+        data["multicommand"] = True
         return data
 
-    async def _x19_multicommand(self, *commands):
+    async def _x19_multicommand(self, *commands) -> dict:
         data = None
         try:
             data = {}

pyasic/config/__init__.py

@@ -214,7 +214,6 @@ class _PoolGroup:
             pools.append(pool.as_x19(user_suffix=user_suffix))
         return pools
 
-
     def as_x17(self, user_suffix: str = None) -> dict:
         """Convert the data in this class to a list usable by an X5 device.
 
@@ -234,7 +233,9 @@ class _PoolGroup:
         }
         for idx, pool in enumerate(self.pools[:3]):
             pools[f"_ant_pool{idx+1}url"] = pool.as_x17(user_suffix=user_suffix)["url"]
-            pools[f"_ant_pool{idx+1}user"] = pool.as_x17(user_suffix=user_suffix)["user"]
+            pools[f"_ant_pool{idx+1}user"] = pool.as_x17(user_suffix=user_suffix)[
+                "user"
+            ]
             pools[f"_ant_pool{idx+1}pw"] = pool.as_x17(user_suffix=user_suffix)["pass"]
 
         return pools
@@ -413,13 +414,13 @@ class MinerConfig:
                 if data[key]:
                     self.miner_mode = X19PowerMode(int(data[key]))
             elif key == "fan_control":
-                for _key in data[key].keys():
+                for _key in data[key]:
                     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():
+                for _key in data[key]:
                     if _key == "mode":
                         self.temp_mode = data[key][_key]
                     elif _key == "target_temp":
@@ -434,7 +435,7 @@ class MinerConfig:
                     self.asicboost = data[key]["asic_boost"]
 
             if key == "autotuning":
-                for _key in data[key].keys():
+                for _key in data[key]:
                     if _key == "enabled":
                         self.autotuning_enabled = data[key][_key]
                     elif _key == "psu_power_limit":
@@ -447,7 +448,7 @@ class MinerConfig:
                         self.autotuning_mode = data[key][_key].replace("_target", "")
 
             if key in ["power_scaling", "performance_scaling"]:
-                for _key in data[key].keys():
+                for _key in data[key]:
                     if _key == "enabled":
                         self.dps_enabled = data[key][_key]
                     elif _key == "power_step":

pyasic/data/error_codes/whatsminer.py

@@ -16,7 +16,7 @@
 
 from dataclasses import asdict, dataclass, field, fields
 
-C_N_CODES = ["52", "53", "54", "55"]
+C_N_CODES = ["52", "53", "54", "55", "56"]
 
 
 @dataclass
@@ -264,6 +264,7 @@ ERROR_CODES = {
     53: {"n": {"c": "Slot {n} chip {c} too few nonce."}},
     54: {"n": {"c": "Slot {n} chip {c} temp protected."}},
     55: {"n": {"c": "Slot {n} chip {c} has been reset."}},
+    56: {"n": {"c": "Slot {n} chip {c} does not return to the nonce."}},
     80: {
         0: {0: "The tool version is too low, please update."},
         1: {0: "Low freq."},

pyasic/load/__init__.py

@@ -19,8 +19,8 @@ from typing import List, Union
 
 from pyasic.errors import APIError
 from pyasic.miners import AnyMiner
-from pyasic.miners.btc._backends import (  # noqa - Ignore access to _module
+from pyasic.miners.backends import (  # noqa - Ignore access to _module
-    X19,
+    AntminerModern,
     BOSMiner,
     BTMiner,
 )
@@ -103,7 +103,7 @@ class _MinerPhaseBalancer:
                     self.miners[str(miner.ip)]["tune"] = True
                     self.miners[str(miner.ip)]["shutdown"] = True
                     self.miners[str(miner.ip)]["max"] = 3600
-            elif isinstance(miner, X19):
+            elif isinstance(miner, AntminerModern):
                 self.miners[str(miner.ip)]["tune"] = False
                 self.miners[str(miner.ip)]["shutdown"] = True
                 self.miners[str(miner.ip)]["max"] = 3600

pyasic/miners/backends/__init__.py

@@ -13,7 +13,9 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-
+from .antminer import AntminerModern, AntminerOld
+from .bfgminer import BFGMiner
+from .bfgminer_goldshell import BFGMinerGoldshell
 from .bmminer import BMMiner
 from .bosminer import BOSMiner
 from .btminer import BTMiner
@@ -21,4 +23,4 @@ from .cgminer import CGMiner
 from .cgminer_avalon import CGMinerAvalon
 from .hiveon import Hiveon
 from .vnish import VNish
-from .X19 import X19
+from .whatsminer import M2X, M3X, M5X

pyasic/miners/backends/antminer.py

@@ -19,17 +19,46 @@ from typing import List, Optional, Union
 
 from pyasic.API import APIError
 from pyasic.config import MinerConfig, X19PowerMode
-from pyasic.data import HashBoard
+from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import MinerErrorData, X19Error
-from pyasic.miners.btc._backends import BMMiner  # noqa - Ignore access to _module
+from pyasic.miners.backends.bmminer import BMMiner
-from pyasic.web.X19 import X19WebAPI
+from pyasic.miners.backends.cgminer import CGMiner
+from pyasic.web.antminer import AntminerModernWebAPI, AntminerOldWebAPI
+
+ANTMINER_MODERN_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "hostname": {"cmd": "get_hostname", "kwargs": {}},
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "get_wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {"cmd": "get_fault_light", "kwargs": {}},
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
 
 
-class X7(BMMiner):
+class AntminerModern(BMMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
-        super().__init__(ip, api_ver=api_ver)
+        super().__init__(ip, api_ver)
-        self.ip = ip
+        # interfaces
-        self.web = X19WebAPI(ip)
+        self.web = AntminerModernWebAPI(ip)
+
+        # static data
+        # data gathering locations
+        self.data_locations = ANTMINER_MODERN_DATA_LOC
+        # autotuning/shutdown support
+        self.supports_shutdown = True
 
     async def get_config(self) -> MinerConfig:
         data = await self.web.get_miner_conf()
@@ -37,97 +66,6 @@ class X7(BMMiner):
             self.config = MinerConfig().from_raw(data)
         return self.config
 
-    async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
-        # get hr from API
-        if not api_summary:
-            try:
-                api_summary = await self.api.summary()
-            except APIError:
-                pass
-
-        if api_summary:
-            try:
-                # not actually GHS, MHS.
-                return round(float(api_summary["SUMMARY"][0]["GHS 5s"] / 1000000), 5)
-            except (IndexError, KeyError, ValueError, TypeError):
-                pass
-
-    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
-        hashboards = []
-
-        if not api_stats:
-            try:
-                api_stats = await self.api.stats()
-            except APIError:
-                pass
-
-        if api_stats:
-            try:
-                board_offset = -1
-                boards = api_stats["STATS"]
-                if len(boards) > 1:
-                    for board_num in range(1, 16, 5):
-                        for _b_num in range(5):
-                            b = boards[1].get(f"chain_acn{board_num + _b_num}")
-
-                            if b and not b == 0 and board_offset == -1:
-                                board_offset = board_num
-                    if board_offset == -1:
-                        board_offset = 1
-
-                    for i in range(board_offset, board_offset + self.ideal_hashboards):
-                        hashboard = HashBoard(
-                            slot=i - board_offset, expected_chips=self.nominal_chips
-                        )
-
-                        chip_temp = boards[1].get(f"temp{i}")
-                        if chip_temp:
-                            hashboard.chip_temp = round(chip_temp)
-
-                        temp = boards[1].get(f"temp2_{i}")
-                        if temp:
-                            hashboard.temp = round(temp)
-
-                        hashrate = boards[1].get(f"chain_rate{i}")
-                        if hashrate:
-                            hashboard.hashrate = round(float(hashrate) / 1000, 5)
-
-                        chips = boards[1].get(f"chain_acn{i}")
-                        if chips:
-                            hashboard.chips = chips
-                            hashboard.missing = False
-                        if (not chips) or (not chips > 0):
-                            hashboard.missing = True
-                        hashboards.append(hashboard)
-            except (IndexError, KeyError, ValueError, TypeError):
-                pass
-
-        return hashboards
-
-    async def get_nominal_hashrate(self, api_stats: dict = None) -> Optional[float]:
-        # X19 method, not sure compatibility
-        if not api_stats:
-            try:
-                api_stats = await self.api.stats()
-            except APIError:
-                pass
-
-        if api_stats:
-            try:
-                ideal_rate = api_stats["STATS"][1]["total_rateideal"]
-                try:
-                    rate_unit = api_stats["STATS"][1]["rate_unit"]
-                except KeyError:
-                    rate_unit = "MH"
-                if rate_unit == "GH":
-                    return round(ideal_rate, 2)
-                if rate_unit == "MH":
-                    return round(ideal_rate / 1000000, 5)
-                else:
-                    return round(ideal_rate, 2)
-            except (KeyError, IndexError):
-                pass
-
     async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
         self.config = config
         conf = config.as_x19(user_suffix=user_suffix)
@@ -160,19 +98,16 @@ class X7(BMMiner):
         return False
 
     async def stop_mining(self) -> bool:
-        return False
+        cfg = await self.get_config()
-        # maybe in a later update
+        cfg.miner_mode = X19PowerMode.Sleep
-        # cfg = await self.get_config()
+        await self.send_config(cfg)
-        # cfg.miner_mode = X19PowerMode.Sleep
+        return True
-        # await self.send_config(cfg)
-        # return True
 
     async def resume_mining(self) -> bool:
-        return False
+        cfg = await self.get_config()
-        # cfg = await self.get_config()
+        cfg.miner_mode = X19PowerMode.Normal
-        # cfg.miner_mode = X19PowerMode.Normal
+        await self.send_config(cfg)
-        # await self.send_config(cfg)
+        return True
-        # return True
 
     async def get_hostname(self) -> Union[str, None]:
         try:
@@ -223,6 +158,29 @@ class X7(BMMiner):
             pass
         return self.light
 
+    async def get_nominal_hashrate(self, api_stats: dict = None) -> Optional[float]:
+        if not api_stats:
+            try:
+                api_stats = await self.api.stats()
+            except APIError:
+                pass
+
+        if api_stats:
+            try:
+                ideal_rate = api_stats["STATS"][1]["total_rateideal"]
+                try:
+                    rate_unit = api_stats["STATS"][1]["rate_unit"]
+                except KeyError:
+                    rate_unit = "GH"
+                if rate_unit == "GH":
+                    return round(ideal_rate / 1000, 2)
+                if rate_unit == "MH":
+                    return round(ideal_rate / 1000000, 2)
+                else:
+                    return round(ideal_rate, 2)
+            except (KeyError, IndexError):
+                pass
+
     async def set_static_ip(
         self,
         ip: str,
@@ -264,3 +222,202 @@ class X7(BMMiner):
             hostname=hostname,
             protocol=protocol,
         )
+
+
+ANTMINER_OLD_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {}},
+    "model": {
+        "cmd": "get_model",
+        "kwargs": {},
+    },
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "hostname": {
+        "cmd": "get_hostname",
+        "kwargs": {"web_get_system_info": {"web": "get_system_info"}},
+    },
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "get_wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {
+        "cmd": "get_fault_light",
+        "kwargs": {"web_get_blink_status": {"web": "get_blink_status"}},
+    },
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
+
+
+class AntminerOld(CGMiner):
+    def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
+        super().__init__(ip, api_ver)
+        # interfaces
+        self.web = AntminerOldWebAPI(ip)
+
+        # static data
+        # data gathering locations
+        self.data_locations = ANTMINER_OLD_DATA_LOC
+
+    async def get_config(self) -> MinerConfig:
+        data = await self.web.get_miner_conf()
+        if data:
+            self.config = MinerConfig().from_raw(data)
+        return self.config
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        await self.web.set_miner_conf(config.as_x17(user_suffix=user_suffix))
+
+    async def get_mac(self) -> Union[str, None]:
+        try:
+            data = await self.web.get_system_info()
+            if data:
+                return data["macaddr"]
+        except KeyError:
+            pass
+
+    async def fault_light_on(self) -> bool:
+        # this should time out, after it does do a check
+        await self.web.blink(blink=True)
+        try:
+            data = await self.web.get_blink_status()
+            if data:
+                if data["isBlinking"]:
+                    self.light = True
+        except KeyError:
+            pass
+        return self.light
+
+    async def fault_light_off(self) -> bool:
+        await self.web.blink(blink=False)
+        try:
+            data = await self.web.get_blink_status()
+            if data:
+                if not data["isBlinking"]:
+                    self.light = False
+        except KeyError:
+            pass
+        return self.light
+
+    async def reboot(self) -> bool:
+        data = await self.web.reboot()
+        if data:
+            return True
+        return False
+
+    async def get_fault_light(self, web_get_blink_status: dict = None) -> bool:
+        if self.light:
+            return self.light
+
+        if not web_get_blink_status:
+            try:
+                web_get_blink_status = await self.web.get_blink_status()
+            except APIError:
+                pass
+
+        if web_get_blink_status:
+            try:
+                self.light = web_get_blink_status["isBlinking"]
+            except KeyError:
+                pass
+        return self.light
+
+    async def get_hostname(self, web_get_system_info: dict = None) -> Optional[str]:
+        if not web_get_system_info:
+            try:
+                web_get_system_info = await self.web.get_system_info()
+            except APIError:
+                pass
+
+        if web_get_system_info:
+            try:
+                return web_get_system_info["hostname"]
+            except KeyError:
+                pass
+
+    async def get_fans(self, api_stats: dict = None) -> List[Fan]:
+        if not api_stats:
+            try:
+                api_stats = await self.api.stats()
+            except APIError:
+                pass
+
+        fans_data = [Fan(), Fan(), Fan(), Fan()]
+        if api_stats:
+            try:
+                fan_offset = -1
+
+                for fan_num in range(1, 8, 4):
+                    for _f_num in range(4):
+                        f = api_stats["STATS"][1].get(f"fan{fan_num + _f_num}")
+                        if f and not f == 0 and fan_offset == -1:
+                            fan_offset = fan_num + 2
+                if fan_offset == -1:
+                    fan_offset = 3
+
+                for fan in range(self.fan_count):
+                    fans_data[fan] = Fan(
+                        api_stats["STATS"][1].get(f"fan{fan_offset+fan}")
+                    )
+            except (KeyError, IndexError):
+                pass
+        return fans_data
+
+    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
+        hashboards = []
+
+        if not api_stats:
+            try:
+                api_stats = await self.api.stats()
+            except APIError:
+                pass
+
+        if api_stats:
+            try:
+                board_offset = -1
+                boards = api_stats["STATS"]
+                if len(boards) > 1:
+                    for board_num in range(1, 16, 5):
+                        for _b_num in range(5):
+                            b = boards[1].get(f"chain_acn{board_num + _b_num}")
+
+                            if b and not b == 0 and board_offset == -1:
+                                board_offset = board_num
+                    if board_offset == -1:
+                        board_offset = 1
+
+                    for i in range(board_offset, board_offset + self.ideal_hashboards):
+                        hashboard = HashBoard(
+                            slot=i - board_offset, expected_chips=self.nominal_chips
+                        )
+
+                        chip_temp = boards[1].get(f"temp{i}")
+                        if chip_temp:
+                            hashboard.chip_temp = round(chip_temp)
+
+                        temp = boards[1].get(f"temp2_{i}")
+                        if temp:
+                            hashboard.temp = round(temp)
+
+                        hashrate = boards[1].get(f"chain_rate{i}")
+                        if hashrate:
+                            hashboard.hashrate = round(float(hashrate) / 1000, 2)
+
+                        chips = boards[1].get(f"chain_acn{i}")
+                        if chips:
+                            hashboard.chips = chips
+                            hashboard.missing = False
+                        if (not chips) or (not chips > 0):
+                            hashboard.missing = True
+                        hashboards.append(hashboard)
+            except (IndexError, KeyError, ValueError, TypeError):
+                pass
+
+        return hashboards

pyasic/miners/backends/bfgminer.py

@@ -14,7 +14,6 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
 import logging
 from collections import namedtuple
 from typing import List, Optional, Tuple
@@ -26,18 +25,44 @@ from pyasic.data.error_codes import MinerErrorData
 from pyasic.errors import APIError
 from pyasic.miners.base import BaseMiner
 
+BFGMINER_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "hostname": {"cmd": "get_hostname", "kwargs": {}},
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "get_wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {"cmd": "get_fault_light", "kwargs": {}},
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
+
 
 class BFGMiner(BaseMiner):
     """Base handler for BFGMiner based miners."""
 
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip)
-        self.ip = ipaddress.ip_address(ip)
+        # interfaces
         self.api = BFGMinerAPI(ip, api_ver)
+
+        # static data
         self.api_type = "BFGMiner"
+        # data gathering locations
+        self.data_locations = BFGMINER_DATA_LOC
+
+        # data storage
         self.api_ver = api_ver
-        self.uname = "root"
-        self.pwd = "admin"
 
     async def get_config(self) -> MinerConfig:
         # get pool data
@@ -77,30 +102,6 @@ class BFGMiner(BaseMiner):
     async def get_mac(self) -> str:
         return "00:00:00:00:00:00"
 
-    async def get_model(self, api_devdetails: dict = None) -> Optional[str]:
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-
-        if not api_devdetails:
-            try:
-                api_devdetails = await self.api.devdetails()
-            except APIError:
-                pass
-
-        if api_devdetails:
-            try:
-                self.model = api_devdetails["DEVDETAILS"][0]["Model"].replace(
-                    "Antminer ", ""
-                )
-                logging.debug(f"Found model for {self.ip}: {self.model}")
-                return self.model
-            except (TypeError, IndexError, KeyError):
-                pass
-
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
     async def get_api_ver(self, api_version: dict = None) -> Optional[str]:
         # Check to see if the version info is already cached
         if self.api_ver:

pyasic/miners/backends/bfgminer_goldshell.py

@@ -13,20 +13,53 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from typing import List, Optional
+from typing import List
 
 from pyasic.config import MinerConfig
-from pyasic.data import Fan, HashBoard
+from pyasic.data import HashBoard
 from pyasic.errors import APIError
-from pyasic.miners.hns._backends import BFGMiner
+from pyasic.miners.backends import BFGMiner
 from pyasic.web.goldshell import GoldshellWebAPI
 
+GOLDSHELL_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {"web_setting": {"web": "setting"}}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"web_status": {"web": "status"}}},
+    "hostname": {"cmd": "get_hostname", "kwargs": {}},
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {
+        "cmd": "get_hashboards",
+        "kwargs": {
+            "api_devs": {"api": "devs"},
+            "api_devdetails": {"api": "devdetails"},
+        },
+    },
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "get_wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {"cmd": "get_fault_light", "kwargs": {}},
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
 
-class Goldshell(BFGMiner):
+
+class BFGMinerGoldshell(BFGMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip, api_ver)
+        # interfaces
         self.web = GoldshellWebAPI(ip)
 
+        # static data
+        # data gathering locations
+        self.data_locations = GOLDSHELL_DATA_LOC
+
     async def get_config(self) -> MinerConfig:
         return MinerConfig().from_raw(await self.web.pools())
 
@@ -75,7 +108,9 @@ class Goldshell(BFGMiner):
             except KeyError:
                 pass
 
-    async def get_hashboards(self, api_devs: dict = None, api_devdetails: dict = None) -> List[HashBoard]:
+    async def get_hashboards(
+        self, api_devs: dict = None, api_devdetails: dict = None
+    ) -> List[HashBoard]:
         if not api_devs:
             try:
                 api_devs = await self.api.devs()
@@ -88,15 +123,20 @@ class Goldshell(BFGMiner):
         ]
 
         if api_devs:
-            for board in api_devs["DEVS"]:
+            if api_devs.get("DEVS"):
-                if board.get("ID") is not None:
+                for board in api_devs["DEVS"]:
-                    try:
+                    if board.get("ID") is not None:
-                        b_id = board["ID"]
+                        try:
-                        hashboards[b_id].hashrate = round(board["MHS 20s"] / 1000000, 2)
+                            b_id = board["ID"]
-                        hashboards[b_id].temp = board["tstemp-2"]
+                            hashboards[b_id].hashrate = round(
-                        hashboards[b_id].missing = False
+                                board["MHS 20s"] / 1000000, 2
-                    except KeyError:
+                            )
-                        pass
+                            hashboards[b_id].temp = board["tstemp-2"]
+                            hashboards[b_id].missing = False
+                        except KeyError:
+                            pass
+            else:
+                print(self, api_devs)
 
         if not api_devdetails:
             try:
@@ -105,12 +145,15 @@ class Goldshell(BFGMiner):
                 pass
 
         if api_devdetails:
-            for board in api_devdetails["DEVS"]:
+            if api_devdetails.get("DEVS"):
-                if board.get("ID") is not None:
+                for board in api_devdetails["DEVS"]:
-                    try:
+                    if board.get("ID") is not None:
-                        b_id = board["ID"]
+                        try:
-                        hashboards[b_id].chips = board["chips-nr"]
+                            b_id = board["ID"]
-                    except KeyError:
+                            hashboards[b_id].chips = board["chips-nr"]
-                        pass
+                        except KeyError:
+                            pass
+            else:
+                print(self, api_devdetails)
 
         return hashboards

pyasic/miners/backends/bmminer.py

@@ -14,7 +14,6 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
 import logging
 from collections import namedtuple
 from typing import List, Optional, Tuple
@@ -28,18 +27,44 @@ from pyasic.data.error_codes import MinerErrorData
 from pyasic.errors import APIError
 from pyasic.miners.base import BaseMiner
 
+BMMINER_DATA_LOC = {
+    "mac": {"cmd": "mac", "kwargs": {}},
+    "model": {"cmd": "model", "kwargs": {"api_devdetails": {"api": "devdetails"}}},
+    "api_ver": {"cmd": "api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "fw_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "hostname": {"cmd": "hostname", "kwargs": {}},
+    "hashrate": {"cmd": "hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "env_temp", "kwargs": {}},
+    "wattage": {"cmd": "wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "fan_psu", "kwargs": {}},
+    "errors": {"cmd": "errors", "kwargs": {}},
+    "fault_light": {"cmd": "fault_light", "kwargs": {}},
+    "pools": {"cmd": "pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
+
 
 class BMMiner(BaseMiner):
     """Base handler for BMMiner based miners."""
 
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip)
-        self.ip = ipaddress.ip_address(ip)
+        # interfaces
         self.api = BMMinerAPI(ip, api_ver)
+
+        # static data
         self.api_type = "BMMiner"
+        # data gathering locations
+        self.data_locations = BMMINER_DATA_LOC
+
+        # data storage
         self.api_ver = api_ver
-        self.uname = "root"
-        self.pwd = "admin"
 
     async def send_ssh_command(self, cmd: str) -> Optional[str]:
         result = None
@@ -115,30 +140,6 @@ class BMMiner(BaseMiner):
     async def get_mac(self) -> str:
         return "00:00:00:00:00:00"
 
-    async def get_model(self, api_devdetails: dict = None) -> Optional[str]:
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-
-        if not api_devdetails:
-            try:
-                api_devdetails = await self.api.devdetails()
-            except APIError:
-                pass
-
-        if api_devdetails:
-            try:
-                self.model = api_devdetails["DEVDETAILS"][0]["Model"].replace(
-                    "Antminer ", ""
-                )
-                logging.debug(f"Found model for {self.ip}: {self.model}")
-                return self.model
-            except (TypeError, IndexError, KeyError):
-                pass
-
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
     async def get_api_ver(self, api_version: dict = None) -> Optional[str]:
         # Check to see if the version info is already cached
         if self.api_ver:
@@ -193,8 +194,7 @@ class BMMiner(BaseMiner):
     async def get_hostname(self) -> Optional[str]:
         hn = await self.send_ssh_command("cat /proc/sys/kernel/hostname")
         if hn:
-            self.hostname = hn
+            return hn
-        return self.hostname
 
     async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
         # get hr from API

pyasic/miners/backends/bosminer.py

@@ -14,14 +14,11 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
-import json
 import logging
 from collections import namedtuple
 from typing import List, Optional, Tuple, Union
 
 import asyncssh
-import httpx
 import toml
 
 from pyasic.API.bosminer import BOSMinerAPI
@@ -30,18 +27,167 @@ from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import BraiinsOSError, MinerErrorData
 from pyasic.errors import APIError
 from pyasic.miners.base import BaseMiner
+from pyasic.web.bosminer import BOSMinerWebAPI
+
+BOSMINER_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {
+        "cmd": "get_api_ver",
+        "kwargs": {"api_version": {"api": "version"}},
+    },
+    "fw_ver": {
+        "cmd": "get_fw_ver",
+        "kwargs": {
+            "graphql_version": {"web": {"bos": {"info": {"version": {"full": None}}}}}
+        },
+    },
+    "hostname": {
+        "cmd": "get_hostname",
+        "kwargs": {"graphql_hostname": {"web": {"bos": {"hostname": None}}}},
+    },
+    "hashrate": {
+        "cmd": "get_hashrate",
+        "kwargs": {
+            "api_summary": {"api": "summary"},
+            "graphql_hashrate": {
+                "web": {
+                    "bosminer": {
+                        "info": {"workSolver": {"realHashrate": {"mhs1M": None}}}
+                    }
+                },
+            },
+        },
+    },
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_devs": {"api": "devs"}},
+    },
+    "hashboards": {
+        "cmd": "get_hashboards",
+        "kwargs": {
+            "api_temps": {"api": "temps"},
+            "api_devdetails": {"api": "devdetails"},
+            "api_devs": {"api": "devs"},
+            "graphql_boards": {
+                "web": {
+                    "bosminer": {
+                        "info": {
+                            "workSolver": {
+                                "childSolvers": {
+                                    "name": None,
+                                    "realHashrate": {"mhs1M": None},
+                                    "hwDetails": {"chips": None},
+                                    "temperatures": {"degreesC": None},
+                                }
+                            }
+                        }
+                    }
+                },
+            },
+        },
+    },
+    "wattage": {
+        "cmd": "get_wattage",
+        "kwargs": {
+            "api_tunerstatus": {"api": "tunerstatus"},
+            "graphql_wattage": {
+                "web": {
+                    "bosminer": {
+                        "info": {"workSolver": {"power": {"approxConsumptionW": None}}}
+                    }
+                }
+            },
+        },
+    },
+    "wattage_limit": {
+        "cmd": "get_wattage_limit",
+        "kwargs": {
+            "api_tunerstatus": {"api": "tunerstatus"},
+            "graphql_wattage_limit": {
+                "web": {
+                    "bosminer": {"info": {"workSolver": {"power": {"limitW": None}}}}
+                }
+            },
+        },
+    },
+    "fans": {
+        "cmd": "get_fans",
+        "kwargs": {
+            "api_fans": {"api": "fans"},
+            "graphql_fans": {
+                "web": {"bosminer": {"info": {"fans": {"name": None, "rpm": None}}}}
+            },
+        },
+    },
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "errors": {
+        "cmd": "get_errors",
+        "kwargs": {
+            "api_tunerstatus": {"api": "tunerstatus"},
+            "graphql_errors": {
+                "web": {
+                    "bosminer": {
+                        "info": {
+                            "workSolver": {
+                                "childSolvers": {
+                                    "name": None,
+                                    "tuner": {"statusMessages": None},
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        },
+    },
+    "fault_light": {
+        "cmd": "get_fault_light",
+        "kwargs": {"graphql_fault_light": {"web": {"bos": {"faultLight": None}}}},
+    },
+    "pools": {
+        "cmd": "get_pools",
+        "kwargs": {
+            "api_pools": {"api": "pools"},
+            "graphql_pools": {
+                "web": {
+                    "bosminer": {
+                        "config": {
+                            "... on BosminerConfig": {
+                                "groups": {
+                                    "pools": {"urluser": None},
+                                    "strategy": {
+                                        "... on QuotaStrategy": {"quota": None}
+                                    },
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        },
+    },
+}
 
 
 class BOSMiner(BaseMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip)
-        self.ip = ipaddress.ip_address(ip)
+        # interfaces
         self.api = BOSMinerAPI(ip, api_ver)
+        self.web = BOSMinerWebAPI(ip)
+
+        # static data
         self.api_type = "BOSMiner"
+        # data gathering locations
+        self.data_locations = BOSMINER_DATA_LOC
+        # autotuning/shutdown support
+        self.supports_autotuning = True
+        self.supports_shutdown = True
+
+        # data storage
         self.api_ver = api_ver
-        self.uname = "root"
-        self.pwd = "admin"
-        self.config = None
 
     async def send_ssh_command(self, cmd: str) -> Optional[str]:
         result = None
@@ -58,8 +204,12 @@ class BOSMiner(BaseMiner):
                 try:
                     # run the command and get the result
                     result = await conn.run(cmd)
+                    stderr = result.stderr
                     result = result.stdout
 
+                    if len(stderr) > len(result):
+                        result = stderr
+
                 except Exception as e:
                     # if the command fails, log it
                     logging.warning(f"{self} command {cmd} error: {e}")
@@ -71,49 +221,6 @@ class BOSMiner(BaseMiner):
         # return the result, either command output or None
         return result
 
-    async def send_graphql_query(self, query) -> Union[dict, None]:
-        # FW version must be equal to or greater than 21.09 to use this
-        if self.fw_ver:
-            try:
-                if not (
-                    (
-                        int(self.fw_ver.split(".")[0]) == 21
-                        and int(self.fw_ver.split(".")[1]) >= 9
-                    )
-                    or int(self.fw_ver.split(".")[0]) > 21
-                ):
-                    logging.info(f"FW version {self.fw_ver} is too low to use graphql.")
-                    return None
-            except ValueError:
-                pass
-
-        url = f"http://{self.ip}/graphql"
-        try:
-            async with httpx.AsyncClient() as client:
-                _auth = await client.post(
-                    url,
-                    json={
-                        "query": 'mutation{auth{login(username:"'
-                        + self.uname
-                        + '", password:"'
-                        + self.pwd
-                        + '"){__typename}}}'
-                    },
-                )
-                d = await client.post(url, json={"query": query})
-            if d.status_code == 200:
-                try:
-                    data = d.json()
-                except json.decoder.JSONDecodeError:
-                    raise APIError(f"GraphQL returned malformed data: {d.text}")
-                if data.get("errors"):
-                    if len(data["errors"]) > 0:
-                        raise APIError(f"GraphQL error: {data['errors'][0]['message']}")
-
-        except httpx.HTTPError:
-            return None
-        return None
-
     async def fault_light_on(self) -> bool:
         """Sends command to turn on fault light on the miner."""
         logging.debug(f"{self}: Sending fault_light on command.")
@@ -136,7 +243,7 @@ class BOSMiner(BaseMiner):
         return False
 
     async def restart_backend(self) -> bool:
-        """Restart bosminer hashing process.  Wraps [`restart_bosminer`][pyasic.miners.btc._backends.bosminer.BOSMiner.restart_bosminer] to standardize."""
+        """Restart bosminer hashing process.  Wraps [`restart_bosminer`][pyasic.miners.backends.bosminer.BOSMiner.restart_bosminer] to standardize."""
         return await self.restart_bosminer()
 
     async def restart_bosminer(self) -> bool:
@@ -267,37 +374,7 @@ class BOSMiner(BaseMiner):
             pass
 
     async def get_model(self) -> Optional[str]:
-        # check if model is cached
+        return self.model + " (BOS)"
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model} (BOS)")
-            return self.model + " (BOS)"
-
-        # get devdetails data
-        try:
-            version_data = await self.api.devdetails()
-        except APIError as e:
-            version_data = None
-            if e.message == "Not ready":
-                cfg = json.loads(await self.send_ssh_command("bosminer config --data"))
-                model = cfg.get("data").get("format").get("model")
-                if model:
-                    model = model.replace("Antminer ", "")
-                    self.model = model
-                    return self.model + " (BOS)"
-
-        # if we get data back, parse it for model
-        if version_data:
-            if not version_data["DEVDETAILS"] == []:
-                # handle Antminer BOSMiner as a base
-                self.model = version_data["DEVDETAILS"][0]["Model"].replace(
-                    "Antminer ", ""
-                )
-                logging.debug(f"Found model for {self.ip}: {self.model} (BOS)")
-                return self.model + " (BOS)"
-
-        # if we don't get devdetails, log a failed attempt
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
 
     async def get_version(
         self, api_version: dict = None, graphql_version: dict = None
@@ -329,8 +406,8 @@ class BOSMiner(BaseMiner):
     async def get_fw_ver(self, graphql_version: dict = None) -> Optional[str]:
         if not graphql_version:
             try:
-                graphql_version = await self.send_graphql_query(
+                graphql_version = await self.web.send_command(
-                    "{bos{info{version{full}}}}"
+                    {"bos": {"info": {"version": {"full"}}}}
                 )
             except APIError:
                 pass
@@ -357,18 +434,20 @@ class BOSMiner(BaseMiner):
         return self.fw_ver
 
     async def get_hostname(self, graphql_hostname: dict = None) -> Union[str, None]:
-        if self.hostname:
+        hostname = None
-            return self.hostname
 
         if not graphql_hostname:
             try:
-                graphql_hostname = await self.send_graphql_query("{bos {hostname}}")
+                graphql_hostname = await self.web.send_command({"bos": {"hostname"}})
             except APIError:
                 pass
 
         if graphql_hostname:
-            self.hostname = graphql_hostname["bos"]["hostname"]
+            try:
-            return self.hostname
+                hostname = graphql_hostname["bos"]["hostname"]
+                return hostname
+            except KeyError:
+                pass
 
         try:
             async with (await self._get_ssh_connection()) as conn:
@@ -376,12 +455,12 @@ class BOSMiner(BaseMiner):
                     data = await conn.run("cat /proc/sys/kernel/hostname")
                     host = data.stdout.strip()
                     logging.debug(f"Found hostname for {self.ip}: {host}")
-                    self.hostname = host
+                    hostname = host
                 else:
                     logging.warning(f"Failed to get hostname for miner: {self}")
         except Exception as e:
             logging.warning(f"Failed to get hostname for miner: {self}, {e}")
-        return self.hostname
+        return hostname
 
     async def get_hashrate(
         self, api_summary: dict = None, graphql_hashrate: dict = None
@@ -390,8 +469,8 @@ class BOSMiner(BaseMiner):
         # get hr from graphql
         if not graphql_hashrate:
             try:
-                graphql_hashrate = await self.send_graphql_query(
+                graphql_hashrate = await self.web.send_command(
-                    "{bosminer{info{workSolver{realHashrate{mhs1M}}}}}"
+                    {"bosminer": {"info": {"workSolver": {"realHashrate": {"mhs1M"}}}}}
                 )
             except APIError:
                 pass
@@ -437,8 +516,21 @@ class BOSMiner(BaseMiner):
 
         if not graphql_boards and not (api_devs or api_temps or api_devdetails):
             try:
-                graphql_boards = await self.send_graphql_query(
+                graphql_boards = await self.web.send_command(
-                    "{bosminer{info{workSolver{childSolvers{name, realHashrate {mhs1M}, hwDetails {chips}, temperatures {degreesC}}}}}}"
+                    {
+                        "bosminer": {
+                            "info": {
+                                "workSolver": {
+                                    "childSolvers": {
+                                        "name": None,
+                                        "realHashrate": {"mhs1M"},
+                                        "hwDetails": {"chips"},
+                                        "temperatures": {"degreesC"},
+                                    }
+                                }
+                            }
+                        }
+                    },
                 )
             except APIError:
                 pass
@@ -536,7 +628,7 @@ class BOSMiner(BaseMiner):
 
         return hashboards
 
-    async def get_env_temp(self, *args, **kwargs) -> Optional[float]:
+    async def get_env_temp(self) -> Optional[float]:
         return None
 
     async def get_wattage(
@@ -544,8 +636,12 @@ class BOSMiner(BaseMiner):
     ) -> Optional[int]:
         if not graphql_wattage and not api_tunerstatus:
             try:
-                graphql_wattage = await self.send_graphql_query(
+                graphql_wattage = await self.web.send_command(
-                    "{bosminer{info{workSolver{power{approxConsumptionW}}}}}"
+                    {
+                        "bosminer": {
+                            "info": {"workSolver": {"power": {"approxConsumptionW"}}}
+                        }
+                    }
                 )
             except APIError:
                 pass
@@ -577,8 +673,8 @@ class BOSMiner(BaseMiner):
     ) -> Optional[int]:
         if not graphql_wattage_limit and not api_tunerstatus:
             try:
-                graphql_wattage_limit = await self.send_graphql_query(
+                graphql_wattage_limit = await self.web.send_command(
-                    "{bosminer{info{workSolver{power{limitW}}}}}"
+                    {"bosminer": {"info": {"workSolver": {"power": {"limitW"}}}}}
                 )
             except APIError:
                 pass
@@ -608,8 +704,8 @@ class BOSMiner(BaseMiner):
     ) -> List[Fan]:
         if not graphql_fans and not api_fans:
             try:
-                graphql_fans = await self.send_graphql_query(
+                graphql_fans = await self.web.send_command(
-                    "{bosminer{info{fans{name, rpm}}}"
+                    {"bosminer": {"info": {"fans": {"name", "rpm"}}}}
                 )
             except APIError:
                 pass
@@ -636,7 +732,7 @@ class BOSMiner(BaseMiner):
             for n in range(self.fan_count):
                 try:
                     fans[f"fan_{n + 1}"].speed = api_fans["FANS"][n]["RPM"]
-                except KeyError:
+                except (IndexError, KeyError):
                     pass
             return [fans["fan_1"], fans["fan_2"], fans["fan_3"], fans["fan_4"]]
         return [Fan(), Fan(), Fan(), Fan()]
@@ -649,8 +745,19 @@ class BOSMiner(BaseMiner):
     ) -> List[dict]:
         if not graphql_pools and not api_pools:
             try:
-                graphql_pools = await self.send_graphql_query(
+                graphql_pools = await self.web.send_command(
-                    "bosminer{config{... on BosminerConfig{groups{pools{urluser}strategy{... on QuotaStrategy{quota}}}}}"
+                    {
+                        "bosminer": {
+                            "config": {
+                                "... on BosminerConfig": {
+                                    "groups": {
+                                        "pools": {"urluser"},
+                                        "strategy": {"... on QuotaStrategy": {"quota"}},
+                                    }
+                                }
+                            }
+                        }
+                    }
                 )
             except APIError:
                 pass
@@ -682,30 +789,44 @@ class BOSMiner(BaseMiner):
         if api_pools:
             seen = []
             groups = [{"quota": "0"}]
-            for i, pool in enumerate(api_pools["POOLS"]):
+            if api_pools.get("POOLS"):
-                if len(seen) == 0:
+                for i, pool in enumerate(api_pools["POOLS"]):
-                    seen.append(pool["User"])
+                    if len(seen) == 0:
-                if not pool["User"] in seen:
+                        seen.append(pool["User"])
-                    # need to use get_config, as this will never read perfectly as there are some bad edge cases
+                    if not pool["User"] in seen:
-                    groups = []
+                        # need to use get_config, as this will never read perfectly as there are some bad edge cases
-                    cfg = await self.get_config()
+                        groups = []
-                    if cfg:
+                        cfg = await self.get_config()
-                        for group in cfg.pool_groups:
+                        if cfg:
-                            pools = {"quota": group.quota}
+                            for group in cfg.pool_groups:
-                            for _i, _pool in enumerate(group.pools):
+                                pools = {"quota": group.quota}
-                                pools[f"pool_{_i + 1}_url"] = _pool.url.replace(
+                                for _i, _pool in enumerate(group.pools):
-                                    "stratum+tcp://", ""
+                                    pools[f"pool_{_i + 1}_url"] = _pool.url.replace(
-                                ).replace("stratum2+tcp://", "")
+                                        "stratum+tcp://", ""
-                                pools[f"pool_{_i + 1}_user"] = _pool.username
+                                    ).replace("stratum2+tcp://", "")
-                            groups.append(pools)
+                                    pools[f"pool_{_i + 1}_user"] = _pool.username
-                    return groups
+                                groups.append(pools)
-                else:
+                        return groups
-                    groups[0][f"pool_{i + 1}_url"] = (
+                    else:
-                        pool["URL"]
+                        groups[0][f"pool_{i + 1}_url"] = (
-                        .replace("stratum+tcp://", "")
+                            pool["URL"]
-                        .replace("stratum2+tcp://", "")
+                            .replace("stratum+tcp://", "")
-                    )
+                            .replace("stratum2+tcp://", "")
-                    groups[0][f"pool_{i + 1}_user"] = pool["User"]
+                        )
+                        groups[0][f"pool_{i + 1}_user"] = pool["User"]
+            else:
+                groups = []
+                cfg = await self.get_config()
+                if cfg:
+                    for group in cfg.pool_groups:
+                        pools = {"quota": group.quota}
+                        for _i, _pool in enumerate(group.pools):
+                            pools[f"pool_{_i + 1}_url"] = _pool.url.replace(
+                                "stratum+tcp://", ""
+                            ).replace("stratum2+tcp://", "")
+                            pools[f"pool_{_i + 1}_user"] = _pool.username
+                        groups.append(pools)
+                return groups
             return groups
 
     async def get_errors(
@@ -713,8 +834,19 @@ class BOSMiner(BaseMiner):
     ) -> List[MinerErrorData]:
         if not graphql_errors and not api_tunerstatus:
             try:
-                graphql_errors = await self.send_graphql_query(
+                graphql_errors = await self.web.send_command(
-                    "{bosminer{info{workSolver{childSolvers{name, tuner{statusMessages}}}}}}"
+                    {
+                        "bosminer": {
+                            "info": {
+                                "workSolver": {
+                                    "childSolvers": {
+                                        "name": None,
+                                        "tuner": {"statusMessages"},
+                                    }
+                                }
+                            }
+                        }
+                    }
                 )
             except APIError:
                 pass
@@ -788,8 +920,8 @@ class BOSMiner(BaseMiner):
                     and int(self.fw_ver.split(".")[1]) > 9
                 ) or int(self.fw_ver.split(".")[0]) > 21:
                     try:
-                        graphql_fault_light = await self.send_graphql_query(
+                        graphql_fault_light = await self.web.send_command(
-                            "{bos {faultLight}}"
+                            {"bos": {"faultLight"}}
                         )
                     except APIError:
                         pass
@@ -800,8 +932,8 @@ class BOSMiner(BaseMiner):
             else:
                 # worth trying
                 try:
-                    graphql_fault_light = await self.send_graphql_query(
+                    graphql_fault_light = await self.web.send_command(
-                        "{bos {faultLight}}"
+                        {"bos": {"faultLight"}}
                     )
                 except APIError:
                     logging.debug(

pyasic/miners/backends/bosminer_old.py

@@ -14,28 +14,20 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
 import logging
 from typing import List, Optional, Tuple
 
 import asyncssh
 
-from pyasic.API.bosminer import BOSMinerAPI
 from pyasic.config import MinerConfig
 from pyasic.data import Fan, HashBoard, MinerData
 from pyasic.data.error_codes import MinerErrorData
-from pyasic.errors import APIError
+from pyasic.miners.backends import BOSMiner
-from pyasic.miners.base import BaseMiner
 
 
-class BOSMinerOld(BaseMiner):
+class BOSMinerOld(BOSMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
-        super().__init__(ip)
+        super().__init__(ip, api_ver)
-        self.ip = ipaddress.ip_address(ip)
-        self.api = BOSMinerAPI(ip, api_ver)
-        self.api_type = "BOSMiner"
-        self.uname = "root"
-        self.pwd = "admin"
 
     async def send_ssh_command(self, cmd: str) -> Optional[str]:
         result = None
@@ -103,80 +95,59 @@ class BOSMinerOld(BaseMiner):
     ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
     ##################################################
 
-    async def get_mac(self) -> Optional[str]:
+    async def get_mac(self, *args, **kwargs) -> Optional[str]:
         return None
 
-    async def get_model(self) -> str:
+    async def get_model(self, *args, **kwargs) -> str:
         return "S9"
 
-    async def get_version(self) -> Tuple[Optional[str], Optional[str]]:
+    async def get_version(self, *args, **kwargs) -> Tuple[Optional[str], Optional[str]]:
         return None, None
 
-    async def get_hostname(self) -> Optional[str]:
+    async def get_hostname(self, *args, **kwargs) -> Optional[str]:
         return None
 
-    async def get_hashrate(self) -> Optional[float]:
+    async def get_hashrate(self, *args, **kwargs) -> Optional[float]:
         return None
 
-    async def get_hashboards(self) -> List[HashBoard]:
+    async def get_hashboards(self, *args, **kwargs) -> List[HashBoard]:
         return []
 
-    async def get_env_temp(self) -> Optional[float]:
+    async def get_env_temp(self, *args, **kwargs) -> Optional[float]:
         return None
 
-    async def get_wattage(self) -> Optional[int]:
+    async def get_wattage(self, *args, **kwargs) -> Optional[int]:
         return None
 
-    async def get_wattage_limit(self) -> Optional[int]:
+    async def get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
         return None
 
     async def get_fans(
         self,
+        *args,
+        **kwargs,
     ) -> List[Fan]:
         return [Fan(), Fan(), Fan(), Fan()]
 
-    async def get_fan_psu(self) -> Optional[int]:
+    async def get_fan_psu(self, *args, **kwargs) -> Optional[int]:
         return None
 
-    async def get_api_ver(self) -> Optional[str]:
+    async def get_api_ver(self, *args, **kwargs) -> Optional[str]:
         return None
 
-    async def get_fw_ver(self) -> Optional[str]:
+    async def get_fw_ver(self, *args, **kwargs) -> Optional[str]:
         return None
 
-    async def get_pools(self, api_pools: dict = None) -> List[dict]:
+    async def get_pools(self, *args, **kwargs) -> List[dict]:
-        groups = []
-
-        if not api_pools:
-            try:
-                api_pools = await self.api.pools()
-            except APIError:
-                pass
-
-        if api_pools:
-            try:
-                pools = {}
-                for i, pool in enumerate(api_pools["POOLS"]):
-                    pools[f"pool_{i + 1}_url"] = (
-                        pool["URL"]
-                        .replace("stratum+tcp://", "")
-                        .replace("stratum2+tcp://", "")
-                    )
-                    pools[f"pool_{i + 1}_user"] = pool["User"]
-                    pools["quota"] = pool["Quota"] if pool.get("Quota") else "0"
-
-                groups.append(pools)
-            except KeyError:
-                pass
-        return groups
-
-    async def get_errors(self) -> List[MinerErrorData]:
         return []
 
-    async def get_fault_light(self) -> bool:
+    async def get_errors(self, *args, **kwargs) -> List[MinerErrorData]:
+        return []
+
+    async def get_fault_light(self, *args, **kwargs) -> bool:
         return False
 
-    async def get_nominal_hashrate(self) -> Optional[float]:
+    async def get_nominal_hashrate(self, *args, **kwargs) -> Optional[float]:
         return None
 
     async def get_data(self, allow_warning: bool = False, **kwargs) -> MinerData:

pyasic/miners/backends/btminer.py

@@ -14,7 +14,6 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
 import logging
 import warnings
 from collections import namedtuple
@@ -27,13 +26,85 @@ from pyasic.data.error_codes import MinerErrorData, WhatsminerError
 from pyasic.errors import APIError
 from pyasic.miners.base import BaseMiner
 
+BTMINER_DATA_LOC = {
+    "mac": {
+        "cmd": "get_mac",
+        "kwargs": {
+            "api_summary": {"api": "summary"},
+            "api_get_miner_info": {"api": "get_miner_info"},
+        },
+    },
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {
+        "cmd": "get_api_ver",
+        "kwargs": {"api_get_version": {"api": "get_version"}},
+    },
+    "fw_ver": {
+        "cmd": "get_fw_ver",
+        "kwargs": {
+            "api_get_version": {"api": "get_version"},
+            "api_summary": {"api": "summary"},
+        },
+    },
+    "hostname": {
+        "cmd": "get_hostname",
+        "kwargs": {"api_get_miner_info": {"api": "get_miner_info"}},
+    },
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_summary": {"api": "summary"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_devs": {"api": "devs"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {"api_summary": {"api": "summary"}}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {"api_summary": {"api": "summary"}}},
+    "wattage_limit": {
+        "cmd": "get_wattage_limit",
+        "kwargs": {"api_summary": {"api": "summary"}},
+    },
+    "fans": {
+        "cmd": "get_fans",
+        "kwargs": {
+            "api_summary": {"api": "summary"},
+            "api_get_psu": {"api": "get_psu"},
+        },
+    },
+    "fan_psu": {
+        "cmd": "get_fan_psu",
+        "kwargs": {
+            "api_summary": {"api": "summary"},
+            "api_get_psu": {"api": "get_psu"},
+        },
+    },
+    "errors": {
+        "cmd": "get_errors",
+        "kwargs": {
+            "api_summary": {"api": "summary"},
+            "api_get_error_code": {"api": "get_error_code"},
+        },
+    },
+    "fault_light": {
+        "cmd": "get_fault_light",
+        "kwargs": {"api_get_miner_info": {"api": "get_miner_info"}},
+    },
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
+
 
 class BTMiner(BaseMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip)
-        self.ip = ipaddress.ip_address(ip)
+        # interfaces
         self.api = BTMinerAPI(ip, api_ver)
+
+        # static data
         self.api_type = "BTMiner"
+        # data gathering locations
+        self.data_locations = BTMINER_DATA_LOC
+        # autotuning/shutdown support
+        self.supports_shutdown = True
+
+        # data storage
         self.api_ver = api_ver
 
     async def _reset_api_pwd_to_admin(self, pwd: str):
@@ -203,28 +274,6 @@ class BTMiner(BaseMiner):
             except (KeyError, IndexError):
                 pass
 
-    async def get_model(self, api_devdetails: dict = None) -> Optional[str]:
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-
-        if not api_devdetails:
-            try:
-                api_devdetails = await self.api.devdetails()
-            except APIError:
-                pass
-
-        if api_devdetails:
-            try:
-                self.model = api_devdetails["DEVDETAILS"][0]["Model"].split("V")[0]
-                logging.debug(f"Found model for {self.ip}: {self.model}")
-                return self.model
-            except (TypeError, IndexError, KeyError):
-                pass
-
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
     async def get_version(
         self, api_get_version: dict = None, api_summary: dict = None
     ) -> Tuple[Optional[str], Optional[str]]:
@@ -302,9 +351,7 @@ class BTMiner(BaseMiner):
         return self.fw_ver
 
     async def get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]:
-        if self.hostname:
+        hostname = None
-            return self.hostname
-
         if not api_get_miner_info:
             try:
                 api_get_miner_info = await self.api.get_miner_info()
@@ -313,11 +360,11 @@ class BTMiner(BaseMiner):
 
         if api_get_miner_info:
             try:
-                self.hostname = api_get_miner_info["Msg"]["hostname"]
+                hostname = api_get_miner_info["Msg"]["hostname"]
             except KeyError:
                 return None
 
-        return self.hostname
+        return hostname
 
     async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
         # get hr from API

pyasic/miners/backends/cgminer.py

@@ -14,7 +14,6 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
 import logging
 from collections import namedtuple
 from typing import List, Optional, Tuple
@@ -28,17 +27,42 @@ from pyasic.data.error_codes import MinerErrorData
 from pyasic.errors import APIError
 from pyasic.miners.base import BaseMiner
 
+CGMINER_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "hostname": {"cmd": "get_hostname", "kwargs": {}},
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "get_wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {"cmd": "get_fault_light", "kwargs": {}},
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
+
 
 class CGMiner(BaseMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip)
-        self.ip = ipaddress.ip_address(ip)
+        # interfaces
         self.api = CGMinerAPI(ip, api_ver)
-        self.api_ver = api_ver
+
+        # static data
         self.api_type = "CGMiner"
-        self.uname = "root"
+        # data gathering locations
-        self.pwd = "admin"
+        self.data_locations = CGMINER_DATA_LOC
-        self.config = None
+
+        # data storage
+        self.api_ver = api_ver
 
     async def send_ssh_command(self, cmd: str) -> Optional[str]:
         result = None
@@ -69,7 +93,7 @@ class CGMiner(BaseMiner):
         return result
 
     async def restart_backend(self) -> bool:
-        """Restart cgminer hashing process.  Wraps [`restart_cgminer`][pyasic.miners.btc._backends.cgminer.CGMiner.restart_cgminer] to standardize."""
+        """Restart cgminer hashing process.  Wraps [`restart_cgminer`][pyasic.miners.backends.cgminer.CGMiner.restart_cgminer] to standardize."""
         return await self.restart_cgminer()
 
     async def restart_cgminer(self) -> bool:
@@ -154,30 +178,6 @@ class CGMiner(BaseMiner):
     async def get_mac(self) -> Optional[str]:
         return None
 
-    async def get_model(self, api_devdetails: dict = None) -> Optional[str]:
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-
-        if not api_devdetails:
-            try:
-                api_devdetails = await self.api.devdetails()
-            except APIError:
-                pass
-
-        if api_devdetails:
-            try:
-                self.model = api_devdetails["DEVDETAILS"][0]["Model"].replace(
-                    "Antminer ", ""
-                )
-                logging.debug(f"Found model for {self.ip}: {self.model}")
-                return self.model
-            except (TypeError, IndexError, KeyError):
-                pass
-
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
     async def get_version(
         self, api_version: dict = None
     ) -> Tuple[Optional[str], Optional[str]]:
@@ -229,8 +229,7 @@ class CGMiner(BaseMiner):
         except (asyncssh.Error, OSError):
             return None
         if hn:
-            self.hostname = hn
+            return hn
-        return self.hostname
 
     async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
         # get hr from API

pyasic/miners/backends/cgminer_avalon.py

@@ -22,13 +22,37 @@ from pyasic.config import MinerConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import MinerErrorData
 from pyasic.errors import APIError
-from pyasic.miners.btc._backends import CGMiner
+from pyasic.miners.backends import CGMiner
+
+AVALON_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {"api_version": {"api": "version"}}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "hostname": {"cmd": "get_hostname", "kwargs": {"mac": {"web": "mac"}}},
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {}},
+    "wattage_limit": {"cmd": "get_wattage_limit", "kwargs": {}},
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {"cmd": "get_fault_light", "kwargs": {}},
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
 
 
 class CGMinerAvalon(CGMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip, api_ver)
-        self.ip = ip
+
+        # data gathering locations
+        self.data_locations = AVALON_DATA_LOC
 
     async def fault_light_on(self) -> bool:
         try:

pyasic/miners/backends/hiveon.py

@@ -14,15 +14,11 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-import ipaddress
+from pyasic.miners.backends import BMMiner
-
-from pyasic.miners.btc._backends import BMMiner
 
 
 class Hiveon(BMMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip, api_ver)
-        self.ip = ipaddress.ip_address(ip)
+        # static data
         self.api_type = "Hiveon"
-        self.uname = "root"
-        self.pwd = "admin"

pyasic/miners/backends/vnish.py

@@ -18,35 +18,48 @@ import logging
 from typing import Optional
 
 from pyasic.errors import APIError
-from pyasic.miners.btc._backends.bmminer import BMMiner
+from pyasic.miners.backends.bmminer import BMMiner
 from pyasic.web.vnish import VNishWebAPI
 
+VNISH_DATA_LOC = {
+    "mac": {"cmd": "get_mac", "kwargs": {"web_summary": {"web": "summary"}}},
+    "model": {"cmd": "get_model", "kwargs": {}},
+    "api_ver": {"cmd": "get_api_ver", "kwargs": {"api_version": {"api": "version"}}},
+    "fw_ver": {"cmd": "get_fw_ver", "kwargs": {"web_summary": {"web": "summary"}}},
+    "hostname": {"cmd": "get_hostname", "kwargs": {"web_summary": {"web": "summary"}}},
+    "hashrate": {"cmd": "get_hashrate", "kwargs": {"api_summary": {"api": "summary"}}},
+    "nominal_hashrate": {
+        "cmd": "get_nominal_hashrate",
+        "kwargs": {"api_stats": {"api": "stats"}},
+    },
+    "hashboards": {"cmd": "get_hashboards", "kwargs": {"api_stats": {"api": "stats"}}},
+    "env_temp": {"cmd": "get_env_temp", "kwargs": {}},
+    "wattage": {"cmd": "get_wattage", "kwargs": {"web_summary": {"web": "summary"}}},
+    "wattage_limit": {
+        "cmd": "get_wattage_limit",
+        "kwargs": {"web_settings": {"web": "settings"}},
+    },
+    "fans": {"cmd": "get_fans", "kwargs": {"api_stats": {"api": "stats"}}},
+    "fan_psu": {"cmd": "get_fan_psu", "kwargs": {}},
+    "errors": {"cmd": "get_errors", "kwargs": {}},
+    "fault_light": {"cmd": "get_fault_light", "kwargs": {}},
+    "pools": {"cmd": "get_pools", "kwargs": {"api_pools": {"api": "pools"}}},
+}
+
 
 class VNish(BMMiner):
     def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
         super().__init__(ip, api_ver)
-        self.api_type = "VNish"
+        # interfaces
         self.web = VNishWebAPI(ip)
 
+        # static data
+        self.api_type = "VNish"
+        # data gathering locations
+        self.data_locations = VNISH_DATA_LOC
+
     async def get_model(self, api_stats: dict = None) -> Optional[str]:
-        # check if model is cached
+        return self.model + "(VNISH)"
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model} (VNish)")
-            return self.model + " (VNish)"
-
-        if not api_stats:
-            try:
-                api_stats = await self.api.stats()
-            except APIError:
-                pass
-
-        if api_stats:
-            try:
-                m_type = api_stats["STATS"][0]["Type"]
-                self.model = m_type.split(" ")[1]
-                return self.model
-            except (KeyError, IndexError):
-                pass
 
     async def restart_backend(self) -> bool:
         data = await self.web.restart_vnish()

pyasic/miners/backends/whatsminer.py

@@ -13,5 +13,20 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .bfgminer import BFGMiner
+from pyasic.miners.backends.btminer import BTMiner
-from .goldshell import Goldshell
+
+
+class M5X(BTMiner):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
+        super().__init__(ip, api_ver)
+        self.supports_autotuning = True
+
+
+class M3X(BTMiner):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
+        super().__init__(ip, api_ver)
+        self.supports_autotuning = True
+
+
+class M2X(BTMiner):
+    pass

pyasic/miners/base.py

@@ -29,23 +29,32 @@ from pyasic.errors import APIError
 
 
 class BaseMiner(ABC):
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, ip: str, *args, **kwargs) -> None:
-        self.ip = None
+        # interfaces
         self.api = None
         self.web = None
-        self.uname = None
+
-        self.pwd = None
+        # static data
+        self.ip = ip
         self.api_type = None
-        self.api_ver = None
+        # type
-        self.fw_ver = None
-        self.model = None
         self.make = None
-        self.light = None
+        self.model = None
-        self.hostname = None
+        # physical attributes
+        self.ideal_hashboards = 3
         self.nominal_chips = 1
         self.fan_count = 2
+        # data gathering locations
+        self.data_locations = None
+        # autotuning/shutdown support
+        self.supports_autotuning = False
+        self.supports_shutdown = False
+
+        # data storage
+        self.api_ver = None
+        self.fw_ver = None
+        self.light = None
         self.config = None
-        self.ideal_hashboards = 3
 
     def __new__(cls, *args, **kwargs):
         if cls is BaseMiner:
@@ -70,8 +79,8 @@ class BaseMiner(ABC):
             conn = await asyncssh.connect(
                 str(self.ip),
                 known_hosts=None,
-                username=self.uname,
+                username="root",
-                password=self.pwd,
+                password="root",
                 server_host_key_algs=["ssh-rsa"],
             )
             return conn
@@ -195,14 +204,13 @@ class BaseMiner(ABC):
         """
         pass
 
-    @abstractmethod
     async def get_model(self) -> Optional[str]:
         """Get the model of the miner and return it as a string.
 
         Returns:
             A string representing the model of the miner.
         """
-        pass
+        return self.model
 
     @abstractmethod
     async def get_api_ver(self, *args, **kwargs) -> Optional[str]:
@@ -360,76 +368,75 @@ class BaseMiner(ABC):
                 "fault_light",
                 "pools",
             ]
-        api_params = []
+        api_multicommand = []
-        web_params = []
+        web_multicommand = []
-        gql = False
         for data_name in data_to_get:
-            function = getattr(self, "get_" + data_name)
-            sig = inspect.signature(function)
-            for item in sig.parameters:
-                if item.startswith("api_"):
-                    command = item.replace("api_", "")
-                    api_params.append(command)
-                elif item.startswith("graphql_"):
-                    gql = True
-                elif item.startswith("web_"):
-                    web_params.append(item.replace("web_", ""))
-        api_params = list(set(api_params))
-        web_params = list(set(web_params))
-        miner_data = {}
-        command_data = await self.api.multicommand(
-            *api_params, allow_warning=allow_warning
-        )
-        if gql:
             try:
-                gql_data = await self.send_graphql_query(  # noqa: bosminer only anyway
+                fn_args = self.data_locations[data_name]["kwargs"]
-                    "{bos {hostname}, bosminer{config{... on BosminerConfig{groups{pools{url, user}, strategy{... on QuotaStrategy {quota}}}}}, info{fans{name, rpm}, workSolver{realHashrate{mhs1M}, temperatures{degreesC}, power{limitW, approxConsumptionW}, childSolvers{name, realHashrate{mhs1M}, hwDetails{chips}, tuner{statusMessages}, temperatures{degreesC}}}}}}"
+                for arg_name in fn_args:
-                )
+                    if fn_args[arg_name].get("api"):
-            except APIError:
+                        api_multicommand.append(fn_args[arg_name]["api"])
-                # hostname hates me
+                    if fn_args[arg_name].get("web"):
-                try:
+                        web_multicommand.append(fn_args[arg_name]["web"])
-                    gql_data = await self.send_graphql_query(  # noqa: bosminer only anyway
+            except KeyError as e:
-                        "{bosminer{config{... on BosminerConfig{groups{pools{url, user}, strategy{... on QuotaStrategy {quota}}}}}, info{fans{name, rpm}, workSolver{realHashrate{mhs1M}, temperatures{degreesC}, power{limitW, approxConsumptionW}, childSolvers{name, realHashrate{mhs1M}, hwDetails{chips}, tuner{statusMessages}, temperatures{degreesC}}}}}}"
+                print(e, data_name)
-                    )
+                continue
-                except APIError:
+
-                    # AGAIN???
+        api_multicommand = list(set(api_multicommand))
-                    gql_data = None
+        _web_multicommand = web_multicommand
+        for item in web_multicommand:
+            if item not in _web_multicommand:
+                _web_multicommand.append(item)
+        web_multicommand = _web_multicommand
+        if len(api_multicommand) > 0:
+            api_command_data = await self.api.multicommand(
+                *api_multicommand, allow_warning=allow_warning
+            )
+        else:
+            api_command_data = {}
+        if len(web_multicommand) > 0:
+            web_command_data = await self.web.multicommand(
+                *web_multicommand, allow_warning=allow_warning
+            )
+        else:
+            web_command_data = {}
+
+        miner_data = {}
 
-        web_data = {}
-        for command in web_params:
-            try:
-                cmd_func = getattr(self.web, command)
-                data = await cmd_func()  # noqa: web only anyway
-            except (LookupError, APIError):
-                pass
-            else:
-                web_data[command] = data
         for data_name in data_to_get:
-            function = getattr(self, "get_" + data_name)
+            try:
-            sig = inspect.signature(function)
+                fn_args = self.data_locations[data_name]["kwargs"]
-            kwargs = {}
+                args_to_send = {k: None for k in fn_args}
-            for arg_name in sig.parameters:
+                for arg_name in fn_args:
-                if arg_name.startswith("api_"):
+                    if fn_args[arg_name].get("api"):
-                    try:
+                        if api_command_data.get("multicommand"):
-                        kwargs[arg_name] = command_data[arg_name.replace("api_", "")][0]
+                            args_to_send[arg_name] = api_command_data[
-                    except (KeyError, IndexError):
+                                fn_args[arg_name]["api"]
-                        kwargs[arg_name] = None
+                            ][0]
-                elif arg_name.startswith("graphql_"):
+                        else:
-                    kwargs[
+                            args_to_send[arg_name] = api_command_data
-                        arg_name
+                    if fn_args[arg_name].get("web"):
-                    ] = gql_data  # noqa: variable is not referenced before assignment
+                        if web_command_data.get("multicommand"):
-                elif arg_name.startswith("web_"):
+                            args_to_send[arg_name] = web_command_data[
-                    try:
+                                fn_args[arg_name]["web"]
-                        kwargs[arg_name] = web_data[arg_name.replace("web_", "")]
+                            ]
-                    except (KeyError, IndexError):
+                        else:
-                        kwargs[arg_name] = None
+                            if not web_command_data == {"multicommand": False}:
+                                args_to_send[arg_name] = web_command_data
+            except (KeyError, IndexError) as e:
+                continue
+
+            function = getattr(self, self.data_locations[data_name]["cmd"])
             if not data_name == "pools":
-                miner_data[data_name] = await function(**kwargs)
+                miner_data[data_name] = await function(**args_to_send)
             else:
-                pools_data = await function(**kwargs)
+                pools_data = await function(**args_to_send)
                 if pools_data:
-                    miner_data["pool_1_url"] = pools_data[0]["pool_1_url"]
+                    try:
-                    miner_data["pool_1_user"] = pools_data[0]["pool_1_user"]
+                        miner_data["pool_1_url"] = pools_data[0]["pool_1_url"]
+                        miner_data["pool_1_user"] = pools_data[0]["pool_1_user"]
+                    except KeyError:
+                        pass
                     if len(pools_data) > 1:
                         miner_data["pool_2_url"] = pools_data[1]["pool_2_url"]
                         miner_data["pool_2_user"] = pools_data[1]["pool_2_user"]

pyasic/miners/btc/_backends/X19.py

@@ -1,194 +0,0 @@
-# ------------------------------------------------------------------------------
-#  Copyright 2022 Upstream Data Inc                                            -
-#                                                                              -
-#  Licensed under the Apache License, Version 2.0 (the "License");             -
-#  you may not use this file except in compliance with the License.            -
-#  You may obtain a copy of the License at                                     -
-#                                                                              -
-#      http://www.apache.org/licenses/LICENSE-2.0                              -
-#                                                                              -
-#  Unless required by applicable law or agreed to in writing, software         -
-#  distributed under the License is distributed on an "AS IS" BASIS,           -
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
-#  See the License for the specific language governing permissions and         -
-#  limitations under the License.                                              -
-# ------------------------------------------------------------------------------
-
-import asyncio
-from typing import List, Optional, Union
-
-from pyasic.API import APIError
-from pyasic.config import MinerConfig, X19PowerMode
-from pyasic.data.error_codes import MinerErrorData, X19Error
-from pyasic.miners.btc._backends import BMMiner  # noqa - Ignore access to _module
-from pyasic.web.X19 import X19WebAPI
-
-
-class X19(BMMiner):
-    def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
-        super().__init__(ip, api_ver=api_ver)
-        self.ip = ip
-        self.web = X19WebAPI(ip)
-
-    async def get_config(self) -> MinerConfig:
-        data = await self.web.get_miner_conf()
-        if data:
-            self.config = MinerConfig().from_raw(data)
-        return self.config
-
-    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
-        self.config = config
-        conf = config.as_x19(user_suffix=user_suffix)
-        await self.web.set_miner_conf(conf)
-
-        for i in range(7):
-            data = await self.get_config()
-            if data.as_x19() == conf:
-                break
-            await asyncio.sleep(1)
-
-    async def fault_light_on(self) -> bool:
-        data = await self.web.blink(blink=True)
-        if data:
-            if data.get("code") == "B000":
-                self.light = True
-        return self.light
-
-    async def fault_light_off(self) -> bool:
-        data = await self.web.blink(blink=False)
-        if data:
-            if data.get("code") == "B100":
-                self.light = True
-        return self.light
-
-    async def reboot(self) -> bool:
-        data = await self.web.reboot()
-        if data:
-            return True
-        return False
-
-    async def stop_mining(self) -> bool:
-        cfg = await self.get_config()
-        cfg.miner_mode = X19PowerMode.Sleep
-        await self.send_config(cfg)
-        return True
-
-    async def resume_mining(self) -> bool:
-        cfg = await self.get_config()
-        cfg.miner_mode = X19PowerMode.Normal
-        await self.send_config(cfg)
-        return True
-
-    async def get_hostname(self) -> Union[str, None]:
-        try:
-            data = await self.web.get_system_info()
-            if data:
-                return data["hostname"]
-        except KeyError:
-            pass
-
-    async def get_mac(self) -> Union[str, None]:
-        try:
-            data = await self.web.get_system_info()
-            if data:
-                return data["macaddr"]
-        except KeyError:
-            pass
-
-        try:
-            data = await self.web.get_network_info()
-            if data:
-                return data["macaddr"]
-        except KeyError:
-            pass
-
-    async def get_errors(self) -> List[MinerErrorData]:
-        errors = []
-        data = await self.web.summary()
-        if data:
-            try:
-                for item in data["SUMMARY"][0]["status"]:
-                    try:
-                        if not item["status"] == "s":
-                            errors.append(X19Error(item["msg"]))
-                    except KeyError:
-                        continue
-            except (KeyError, IndexError):
-                pass
-        return errors
-
-    async def get_fault_light(self) -> bool:
-        if self.light:
-            return self.light
-        try:
-            data = await self.web.get_blink_status()
-            if data:
-                self.light = data["blink"]
-        except KeyError:
-            pass
-        return self.light
-
-    async def get_nominal_hashrate(self, api_stats: dict = None) -> Optional[float]:
-        if not api_stats:
-            try:
-                api_stats = await self.api.stats()
-            except APIError:
-                pass
-
-        if api_stats:
-            try:
-                ideal_rate = api_stats["STATS"][1]["total_rateideal"]
-                try:
-                    rate_unit = api_stats["STATS"][1]["rate_unit"]
-                except KeyError:
-                    rate_unit = "GH"
-                if rate_unit == "GH":
-                    return round(ideal_rate / 1000, 2)
-                if rate_unit == "MH":
-                    return round(ideal_rate / 1000000, 2)
-                else:
-                    return round(ideal_rate, 2)
-            except (KeyError, IndexError):
-                pass
-
-    async def set_static_ip(
-        self,
-        ip: str,
-        dns: str,
-        gateway: str,
-        subnet_mask: str = "255.255.255.0",
-        hostname: str = None,
-    ):
-        if not hostname:
-            hostname = await self.get_hostname()
-        await self.web.set_network_conf(
-            ip=ip,
-            dns=dns,
-            gateway=gateway,
-            subnet_mask=subnet_mask,
-            hostname=hostname,
-            protocol=2,
-        )
-
-    async def set_dhcp(self, hostname: str = None):
-        if not hostname:
-            hostname = await self.get_hostname()
-        await self.web.set_network_conf(
-            ip="", dns="", gateway="", subnet_mask="", hostname=hostname, protocol=1
-        )
-
-    async def set_hostname(self, hostname: str):
-        cfg = await self.web.get_network_info()
-        dns = cfg["conf_dnsservers"]
-        gateway = cfg["conf_gateway"]
-        ip = cfg["conf_ipaddress"]
-        subnet_mask = cfg["conf_netmask"]
-        protocol = 1 if cfg["conf_nettype"] == "DHCP" else 2
-        await self.web.set_network_conf(
-            ip=ip,
-            dns=dns,
-            gateway=gateway,
-            subnet_mask=subnet_mask,
-            hostname=hostname,
-            protocol=protocol,
-        )

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S17(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S17"
         self.nominal_chips = 48

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

@@ -18,9 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S17Plus(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
-        self.ip = ip
         self.model = "S17+"
         self.nominal_chips = 65
         self.fan_count = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S17Pro(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S17 Pro"
         self.nominal_chips = 48

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S17e(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S17e"
         self.nominal_chips = 135

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class T17(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "T17"
         self.nominal_chips = 30

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class T17Plus(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "T17+"
         self.nominal_chips = 44

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class T17e(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "T17e"
         self.nominal_chips = 78

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19"
         self.nominal_chips = 76

pyasic/miners/btc/_types/antminer/X19/S19L.py

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19L(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19L"
         self.nominal_chips = 76

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19Pro(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19 Pro"
         self.nominal_chips = 114

pyasic/miners/btc/_types/antminer/X19/S19_XP.py

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19XP(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19 XP"
         self.nominal_chips = 110

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19a(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19a"
         self.nominal_chips = 72

pyasic/miners/btc/_types/antminer/X19/S19a_Pro.py

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19aPro(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19a Pro"
         self.nominal_chips = 100

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19j(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19j"
         self.nominal_chips = 114

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S19jPro(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S19j Pro"
         self.nominal_chips = 126

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class T19(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "T19"
         self.nominal_chips = 76

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S9(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S9"
         self.nominal_chips = 63

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class S9i(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "S9i"
         self.nominal_chips = 63

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AntMiner
 
 
 class T9(AntMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "T9"
         self.nominal_chips = 54

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon1026(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 1026"
         self.nominal_chips = 80

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon1047(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 1047"
         self.nominal_chips = 80

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon1066(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 1066"
         self.nominal_chips = 114

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon721(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 721"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon741(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 741"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon761(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 761"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon821(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 821"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon841(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 841"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon851(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 851"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import AvalonMiner
 
 
 class Avalon921(AvalonMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "Avalon 921"
         self.ideal_hashboards = 4

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import InnosiliconMiner
 
 
 class InnosiliconT3HPlus(InnosiliconMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str) -> None:
+    def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "T3H+"
         self.nominal_chips = 114

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M20V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M20 V10"
         self.nominal_chips = 70

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M20SV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M20S V10"
         self.nominal_chips = 105
@@ -29,8 +29,8 @@ class M20SV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M20SV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M20S V20"
         self.nominal_chips = 111
@@ -38,8 +38,8 @@ class M20SV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M20SV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M20S V30"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M20SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M20S+ V30"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M21V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M21 V10"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M21SV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M21S V20"
         self.nominal_chips = 66
@@ -29,8 +29,8 @@ class M21SV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M21SV60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M21S V60"
         self.nominal_chips = 105
@@ -38,8 +38,8 @@ class M21SV60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M21SV70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M21S V70"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M21SPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M21S+ V20"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M2X/M29.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M29V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M29 V10"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M30.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M30V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30 V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M30V10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30V20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30 V20"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M30SV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M30SV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M30SV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V30"
         self.nominal_chips = 0
@@ -56,8 +56,8 @@ class M30SV30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V40"
         self.nominal_chips = 0
@@ -68,8 +68,8 @@ class M30SV40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V50"
         self.nominal_chips = 156
@@ -77,8 +77,8 @@ class M30SV50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V60"
         self.nominal_chips = 0
@@ -89,8 +89,8 @@ class M30SV60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V70"
         self.nominal_chips = 0
@@ -101,8 +101,8 @@ class M30SV70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SV80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S V80"
         self.nominal_chips = 0
@@ -113,8 +113,8 @@ class M30SV80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE10"
         self.nominal_chips = 105
@@ -122,8 +122,8 @@ class M30SVE10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE20"
         self.nominal_chips = 111
@@ -131,8 +131,8 @@ class M30SVE20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE30"
         self.nominal_chips = 0
@@ -143,8 +143,8 @@ class M30SVE30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE40"
         self.nominal_chips = 0
@@ -155,8 +155,8 @@ class M30SVE40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE50"
         self.nominal_chips = 0
@@ -167,8 +167,8 @@ class M30SVE50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE60"
         self.nominal_chips = 0
@@ -179,8 +179,8 @@ class M30SVE60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVE70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VE70"
         self.nominal_chips = 0
@@ -191,8 +191,8 @@ class M30SVE70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVF10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VF10"
         self.nominal_chips = 0
@@ -203,8 +203,8 @@ class M30SVF10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVF20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VF20"
         self.nominal_chips = 0
@@ -215,8 +215,8 @@ class M30SVF20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVF30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VF30"
         self.nominal_chips = 0
@@ -227,8 +227,8 @@ class M30SVF30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVG10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VG10"
         self.nominal_chips = 66
@@ -236,8 +236,8 @@ class M30SVG10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVG20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VG20"
         self.nominal_chips = 70
@@ -245,8 +245,8 @@ class M30SVG20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VG30"
         self.nominal_chips = 0
@@ -257,8 +257,8 @@ class M30SVG30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVG40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VG40"
         self.nominal_chips = 0
@@ -269,8 +269,8 @@ class M30SVG40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVH10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VH10"
         self.nominal_chips = 0
@@ -281,8 +281,8 @@ class M30SVH10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VH20"
         self.nominal_chips = 0
@@ -293,8 +293,8 @@ class M30SVH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VH30"
         self.nominal_chips = 0
@@ -305,8 +305,8 @@ class M30SVH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVH40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VH40"
         self.nominal_chips = 0
@@ -317,8 +317,8 @@ class M30SVH40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVH50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VH50"
         self.nominal_chips = 0
@@ -329,8 +329,8 @@ class M30SVH50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVH60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VH60"
         self.nominal_chips = 0
@@ -341,8 +341,8 @@ class M30SVH60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SVI20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S VI20"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M30SPlusV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M30SPlusV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M30SPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V30"
         self.nominal_chips = 0
@@ -56,8 +56,8 @@ class M30SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V40"
         self.nominal_chips = 0
@@ -68,8 +68,8 @@ class M30SPlusV40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V50"
         self.nominal_chips = 0
@@ -80,8 +80,8 @@ class M30SPlusV50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V60"
         self.nominal_chips = 0
@@ -92,8 +92,8 @@ class M30SPlusV60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V70"
         self.nominal_chips = 0
@@ -104,8 +104,8 @@ class M30SPlusV70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V80"
         self.nominal_chips = 0
@@ -116,8 +116,8 @@ class M30SPlusV80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV90(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V90"
         self.nominal_chips = 0
@@ -128,8 +128,8 @@ class M30SPlusV90(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusV100(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ V100"
         self.nominal_chips = 0
@@ -140,8 +140,8 @@ class M30SPlusV100(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE30"
         self.nominal_chips = 0
@@ -152,8 +152,8 @@ class M30SPlusVE30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE40"
         self.nominal_chips = 156
@@ -161,8 +161,8 @@ class M30SPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE50"
         self.nominal_chips = 0
@@ -173,8 +173,8 @@ class M30SPlusVE50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE60"
         self.nominal_chips = 0
@@ -185,8 +185,8 @@ class M30SPlusVE60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE70"
         self.nominal_chips = 0
@@ -197,8 +197,8 @@ class M30SPlusVE70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE80"
         self.nominal_chips = 0
@@ -209,8 +209,8 @@ class M30SPlusVE80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE90(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE90"
         self.nominal_chips = 0
@@ -221,8 +221,8 @@ class M30SPlusVE90(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVE100(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VE100"
         self.nominal_chips = 0
@@ -233,8 +233,8 @@ class M30SPlusVE100(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVF20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VF20"
         self.nominal_chips = 111
@@ -242,8 +242,8 @@ class M30SPlusVF20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVF30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VF30"
         self.nominal_chips = 0
@@ -254,8 +254,8 @@ class M30SPlusVF30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M36SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M36S+ VG30"
         self.nominal_chips = 0
@@ -266,8 +266,8 @@ class M36SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VG30"
         self.nominal_chips = 0
@@ -278,8 +278,8 @@ class M30SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VG40"
         self.nominal_chips = 105
@@ -287,8 +287,8 @@ class M30SPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVG50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VG50"
         self.nominal_chips = 0
@@ -299,8 +299,8 @@ class M30SPlusVG50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVG60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VG60"
         self.nominal_chips = 86
@@ -308,8 +308,8 @@ class M30SPlusVG60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVH10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VH10"
         self.nominal_chips = 0
@@ -320,8 +320,8 @@ class M30SPlusVH10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VH20"
         self.nominal_chips = 0
@@ -332,8 +332,8 @@ class M30SPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VH30"
         self.nominal_chips = 70
@@ -341,8 +341,8 @@ class M30SPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVH40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VH40"
         self.nominal_chips = 0
@@ -353,8 +353,8 @@ class M30SPlusVH40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVH50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VH50"
         self.nominal_chips = 0
@@ -365,8 +365,8 @@ class M30SPlusVH50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusVH60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S+ VH60"
         self.nominal_chips = 66

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M30SPlusPlusV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M30SPlusPlusV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ V20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M30SPlusPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVE30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VE30"
         self.nominal_chips = 0
@@ -56,8 +56,8 @@ class M30SPlusPlusVE30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VE40"
         self.nominal_chips = 0
@@ -68,8 +68,8 @@ class M30SPlusPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVE50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VE50"
         self.nominal_chips = 0
@@ -80,8 +80,8 @@ class M30SPlusPlusVE50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVF40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VF40"
         self.nominal_chips = 0
@@ -92,8 +92,8 @@ class M30SPlusPlusVF40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VG30"
         self.nominal_chips = 111
@@ -101,8 +101,8 @@ class M30SPlusPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VG40"
         self.nominal_chips = 117
@@ -110,8 +110,8 @@ class M30SPlusPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVG50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VG50"
         self.nominal_chips = 0
@@ -122,8 +122,8 @@ class M30SPlusPlusVG50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH10"
         self.nominal_chips = 0
@@ -134,8 +134,8 @@ class M30SPlusPlusVH10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH20"
         self.nominal_chips = 0
@@ -146,8 +146,8 @@ class M30SPlusPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH30"
         self.nominal_chips = 0
@@ -158,8 +158,8 @@ class M30SPlusPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH40"
         self.nominal_chips = 0
@@ -170,8 +170,8 @@ class M30SPlusPlusVH40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH50"
         self.nominal_chips = 74
@@ -179,8 +179,8 @@ class M30SPlusPlusVH50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH60"
         self.nominal_chips = 78
@@ -188,8 +188,8 @@ class M30SPlusPlusVH60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH70"
         self.nominal_chips = 70
@@ -197,8 +197,8 @@ class M30SPlusPlusVH70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH80"
         self.nominal_chips = 0
@@ -209,8 +209,8 @@ class M30SPlusPlusVH80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH90(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH90"
         self.nominal_chips = 0
@@ -221,8 +221,8 @@ class M30SPlusPlusVH90(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVH100(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VH100"
         self.nominal_chips = 0
@@ -233,8 +233,8 @@ class M30SPlusPlusVH100(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVJ20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VJ20"
         self.nominal_chips = 0
@@ -245,8 +245,8 @@ class M30SPlusPlusVJ20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M30SPlusPlusVJ30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M30S++ VJ30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M31.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M31V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31 V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M31V10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31V20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31 V20"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M31H.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M31HV40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31H V40"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M31SV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V10"
         self.nominal_chips = 105
@@ -29,8 +29,8 @@ class M31SV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V20"
         self.nominal_chips = 111
@@ -38,8 +38,8 @@ class M31SV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V30"
         self.nominal_chips = 0
@@ -50,8 +50,8 @@ class M31SV30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V40"
         self.nominal_chips = 0
@@ -62,8 +62,8 @@ class M31SV40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V50"
         self.nominal_chips = 0
@@ -74,8 +74,8 @@ class M31SV50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V60"
         self.nominal_chips = 105
@@ -83,8 +83,8 @@ class M31SV60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V70"
         self.nominal_chips = 111
@@ -92,8 +92,8 @@ class M31SV70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V80"
         self.nominal_chips = 0
@@ -104,8 +104,8 @@ class M31SV80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SV90(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S V90"
         self.nominal_chips = 0
@@ -116,8 +116,8 @@ class M31SV90(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SVE10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S VE10"
         self.nominal_chips = 0
@@ -128,8 +128,8 @@ class M31SVE10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SVE20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S VE20"
         self.nominal_chips = 0
@@ -140,8 +140,8 @@ class M31SVE20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SVE30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S VE30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M31SE.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M31SEV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31SE V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M31SEV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SEV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31SE V20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M31SEV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SEV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31SE V30"
         self.nominal_chips = 0

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M31SPlusV10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M31SPlusV10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M31SPlusV20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V30"
         self.nominal_chips = 117
@@ -53,8 +53,8 @@ class M31SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V40"
         self.nominal_chips = 123
@@ -62,8 +62,8 @@ class M31SPlusV40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V50"
         self.nominal_chips = 0
@@ -74,8 +74,8 @@ class M31SPlusV50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V60"
         self.nominal_chips = 156
@@ -83,8 +83,8 @@ class M31SPlusV60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V80"
         self.nominal_chips = 129
@@ -92,8 +92,8 @@ class M31SPlusV80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV90(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V90"
         self.nominal_chips = 117
@@ -101,8 +101,8 @@ class M31SPlusV90(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV100(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V100"
         self.nominal_chips = 111
@@ -110,8 +110,8 @@ class M31SPlusV100(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE10"
         self.nominal_chips = 0
@@ -122,8 +122,8 @@ class M31SPlusVE10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE20"
         self.nominal_chips = 78
@@ -131,8 +131,8 @@ class M31SPlusVE20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE30"
         self.nominal_chips = 0
@@ -143,8 +143,8 @@ class M31SPlusVE30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE40"
         self.nominal_chips = 0
@@ -155,8 +155,8 @@ class M31SPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE50"
         self.nominal_chips = 0
@@ -167,8 +167,8 @@ class M31SPlusVE50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE60"
         self.nominal_chips = 0
@@ -179,8 +179,8 @@ class M31SPlusVE60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVE80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VE80"
         self.nominal_chips = 0
@@ -191,8 +191,8 @@ class M31SPlusVE80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVF20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VF20"
         self.nominal_chips = 0
@@ -203,8 +203,8 @@ class M31SPlusVF20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVF30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VF30"
         self.nominal_chips = 0
@@ -215,8 +215,8 @@ class M31SPlusVF30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVG20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VG20"
         self.nominal_chips = 0
@@ -227,8 +227,8 @@ class M31SPlusVG20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ VG30"
         self.nominal_chips = 0
@@ -239,8 +239,8 @@ class M31SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V30"
         self.nominal_chips = 117
@@ -248,8 +248,8 @@ class M31SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M31SPlusV40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M31S+ V40"
         self.nominal_chips = 123

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

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M32V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M32 V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M32V10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M32V20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M32 V20"
         self.nominal_chips = 74

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

@@ -18,8 +18,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M32S(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M32S"
         self.nominal_chips = 78

pyasic/miners/btc/_types/whatsminer/M3X/M33.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M33V10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33 V10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M33V10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M33V20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33 V20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M33V20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M33V30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33 V30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M33S.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M33SVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33S VG30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M33S_Plus.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M33SPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33S+ VH20"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M33SPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M33SPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33S+ VH30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M33S_Plus_Plus.py

@@ -20,10 +20,11 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M33SPlusPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33S++ VH20"
+        self.ideal_hashboards = 4
         self.nominal_chips = 0
         warnings.warn(
             "Unknown chip count for miner type M30S++ VH20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -32,10 +33,11 @@ class M33SPlusPlusVH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M33SPlusPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33S++ VH30"
+        self.ideal_hashboards = 4
         self.nominal_chips = 0
         warnings.warn(
             "Unknown chip count for miner type M30S++ VH30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -44,10 +46,11 @@ class M33SPlusPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M33SPlusPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M33S++ VG40"
+        self.ideal_hashboards = 4
         self.nominal_chips = 0
         warnings.warn(
             "Unknown chip count for miner type M30S++ VG40, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

pyasic/miners/btc/_types/whatsminer/M3X/M34S_Plus.py

@@ -18,8 +18,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M34SPlusVE10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M34S+ VE10"
         self.ideal_hashboards = 4

pyasic/miners/btc/_types/whatsminer/M3X/M36S.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M36SVE10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M36S VE10"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M36S_Plus.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M36SPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M36S+ VG30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M36S_Plus_Plus.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M36SPlusPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M36S++ VH30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M3X/M39.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M39V20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M39 V20"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M50.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M50VG30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VG30"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M50VG30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH10"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M50VH10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH20"
         self.nominal_chips = 111
@@ -53,8 +53,8 @@ class M50VH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH30"
         self.nominal_chips = 0
@@ -65,8 +65,8 @@ class M50VH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH40"
         self.nominal_chips = 84
@@ -74,8 +74,8 @@ class M50VH40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH50"
         self.nominal_chips = 105
@@ -83,8 +83,8 @@ class M50VH50(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH60(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH60"
         self.nominal_chips = 0
@@ -95,8 +95,8 @@ class M50VH60(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH70(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH70"
         self.nominal_chips = 0
@@ -107,8 +107,8 @@ class M50VH70(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VH80(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VH80"
         self.nominal_chips = 0
@@ -119,8 +119,8 @@ class M50VH80(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VJ10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VJ10"
         self.nominal_chips = 0
@@ -131,8 +131,8 @@ class M50VJ10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VJ20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VJ20"
         self.nominal_chips = 0
@@ -143,8 +143,8 @@ class M50VJ20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50VJ30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50 VJ30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M50S.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M50SVJ10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VJ10"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M50SVJ10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVJ20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VJ20"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M50SVJ20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVJ30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VJ30"
         self.nominal_chips = 0
@@ -56,8 +56,8 @@ class M50SVJ30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVH10(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VH10"
         self.nominal_chips = 0
@@ -68,8 +68,8 @@ class M50SVH10(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVH20(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VH20"
         self.nominal_chips = 0
@@ -80,8 +80,8 @@ class M50SVH20(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VH30"
         self.nominal_chips = 0
@@ -92,8 +92,8 @@ class M50SVH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVH40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VH40"
         self.nominal_chips = 0
@@ -104,8 +104,8 @@ class M50SVH40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SVH50(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S VH50"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M50S_Plus.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M50SPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S+ VH30"
         self.nominal_chips = 0
@@ -32,8 +32,8 @@ class M50SPlusVH30(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SPlusVH40(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S+ VH40"
         self.nominal_chips = 0
@@ -44,8 +44,8 @@ class M50SPlusVH40(WhatsMiner):  # noqa - ignore ABC method implementation
 
 
 class M50SPlusVJ30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M50S+ VJ30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M53.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M53VH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M53 VH30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M53S.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M53SVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M53S VH30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M53S_Plus.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M53SPlusVJ30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M53S+ VJ30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M56.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M56VH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M56 VH30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M56S.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M56SVH30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M56S VH30"
         self.nominal_chips = 0

pyasic/miners/btc/_types/whatsminer/M5X/M56S_Plus.py

@@ -20,8 +20,8 @@ from pyasic.miners.makes import WhatsMiner
 
 
 class M56SPlusVJ30(WhatsMiner):  # noqa - ignore ABC method implementation
-    def __init__(self, ip: str):
+    def __init__(self, ip: str, api_ver: str = "0.0.0"):
-        super().__init__()
+        super().__init__(ip, api_ver)
         self.ip = ip
         self.model = "M56S+ VJ30"
         self.nominal_chips = 0