version: bump version number

Allow user to set a flash pattern, and if not, set a nice default flash pattern.

pyasic/API/__init__.py

@@ -148,7 +148,8 @@ If you are sure you want to use this command please use API.send_command("{comma
                 )
         return return_commands
 
-    async def _send_bytes(self, data: bytes) -> bytes:
+    async def _send_bytes(self, data: bytes, timeout: int=100) -> bytes:
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Sending")
         try:
             # get reader and writer streams
             reader, writer = await asyncio.open_connection(str(self.ip), self.port)
@@ -159,23 +160,32 @@ If you are sure you want to use this command please use API.send_command("{comma
             return b"{}"
 
         # send the command
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Writing")
         writer.write(data)
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Draining")
         await writer.drain()
 
         # instantiate data
         ret_data = b""
 
         # loop to receive all the data
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Receiving")
         try:
             while True:
-                d = await reader.read(4096)
-                if not d:
-                    break
-                ret_data += d
+                try:
+                    d = await asyncio.wait_for(reader.read(4096), timeout=timeout)
+                    if not d:
+                        break
+                    ret_data += d
+                except (asyncio.CancelledError, asyncio.TimeoutError) as e:
+                    raise e
+        except (asyncio.CancelledError, asyncio.TimeoutError) as e:
+            raise e
         except Exception as e:
             logging.warning(f"{self} - ([Hidden] Send Bytes) - API Command Error {e}")
 
         # close the connection
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Closing")
         writer.close()
         await writer.wait_closed()
 

pyasic/API/bmminer.py

@@ -34,8 +34,9 @@ class BMMinerAPI(BaseMinerAPI):
         port: The port to reference the API on.  Default is 4028.
     """
 
-    def __init__(self, ip: str, port: int = 4028) -> None:
-        super().__init__(ip, port)
+    def __init__(self, ip: str, api_ver: str = "1.0.0", port: int = 4028) -> None:
+        super().__init__(ip, port=port)
+        self.api_ver = api_ver
 
     async def multicommand(
         self, *commands: str, allow_warning: bool = True

pyasic/API/bosminer.py

@@ -33,8 +33,10 @@ class BOSMinerAPI(BaseMinerAPI):
         port: The port to reference the API on.  Default is 4028.
     """
 
-    def __init__(self, ip: str, port: int = 4028):
-        super().__init__(ip, port)
+    def __init__(self, ip: str, api_ver: str = "1.0.0", port: int = 4028) -> None:
+        super().__init__(ip, port=port)
+        self.api_ver = api_ver
+
 
     async def asccount(self) -> dict:
         """Get data on the number of ASC devices and their info.

pyasic/API/btminer.py

@@ -12,6 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import asyncio
 import base64
 import binascii
 import hashlib
@@ -26,6 +27,7 @@ from passlib.handlers.md5_crypt import md5_crypt
 from pyasic.API import BaseMinerAPI
 from pyasic.errors import APIError
 from pyasic.settings import PyasicSettings
+from pyasic.misc import api_min_version
 
 ### IMPORTANT ###
 # you need to change the password of the miners using the Whatsminer
@@ -123,6 +125,7 @@ def create_privileged_cmd(token_data: dict, command: dict) -> bytes:
     Returns:
         The encrypted privileged command to be sent to the miner.
     """
+    logging.debug(f"(Create Prilileged Command) - Creating Privileged Command")
     # add token to command
     command["token"] = token_data["host_sign"]
     # encode host_passwd data and get hexdigest
@@ -178,26 +181,37 @@ class BTMinerAPI(BaseMinerAPI):
     def __init__(
         self,
         ip: str,
+        api_ver: str = "1.0.0",
         port: int = 4028,
         pwd: str = PyasicSettings().global_whatsminer_password,
     ):
         super().__init__(ip, port)
         self.pwd = pwd
         self.current_token = None
+        self.api_ver = api_ver
+
 
     async def send_privileged_command(
-        self, command: Union[str, bytes], ignore_errors: bool = False, **kwargs
+        self, command: Union[str, bytes], ignore_errors: bool = False, timeout: int = 10, **kwargs
     ) -> dict:
         logging.debug(f"{self} - (Send Privileged Command) - {command} " +  f'with args {kwargs}' if len(kwargs) > 0 else '')
-        command = {"cmd": command}
-        for kwarg in kwargs:
-            if kwargs[kwarg]:
-                command[kwarg] = kwargs[kwarg]
+        command = {"cmd": command, **kwargs}
 
         token_data = await self.get_token()
         enc_command = create_privileged_cmd(token_data, command)
 
-        data = await self._send_bytes(enc_command)
+        logging.debug(f"{self} - (Send Privileged Command) - Sending")
+        try:
+            data = await self._send_bytes(enc_command, timeout)
+        except (asyncio.CancelledError, asyncio.TimeoutError) as e:
+            if command['cmd'] in ['reboot', 'restart']:
+                logging.info(f"{self} - (reboot/restart) - Whatsminers currently break this. "
+                             f"Ignoring exception. Command probably worked.")
+                # FAKING IT HERE
+                data = b'{"STATUS": "S", "When": 1670966423, "Code": 131, "Msg": "API command OK", "Description": "Reboot"}'
+            else:
+                raise APIError("No data was returned from the API.")
+
         if not data:
             raise APIError("No data was returned from the API.")
         data = self._load_api_data(data)
@@ -369,8 +383,8 @@ class BTMinerAPI(BaseMinerAPI):
         self,
         auto: bool = True,
         color: str = "red",
-        period: int = 60,
-        duration: int = 20,
+        period: int = 400,
+        duration: int = 200,
         start: int = 0,
     ) -> dict:
         """Set the LED on the miner using the API.
@@ -392,7 +406,7 @@ class BTMinerAPI(BaseMinerAPI):
         </details>
         """
         if auto:
-            return await self.send_privileged_command("set_led", param=auto)
+            return await self.send_privileged_command("set_led", param="auto")
         return await self.send_privileged_command(
             "set_led", color=color, period=period, duration=duration, start=start
         )
@@ -418,7 +432,7 @@ class BTMinerAPI(BaseMinerAPI):
         # requires a file stream in bytes
         return NotImplementedError
 
-    async def reboot(self) -> dict:
+    async def reboot(self, timeout: int = 10) -> dict:
         """Reboot the miner using the API.
         <details>
             <summary>Expand</summary>
@@ -428,7 +442,12 @@ class BTMinerAPI(BaseMinerAPI):
             A reply informing of the status of the reboot.
         </details>
         """
-        return await self.send_privileged_command("reboot")
+        try:
+            d = await asyncio.wait_for(self.send_privileged_command("reboot"), timeout=timeout)
+        except (asyncio.CancelledError, asyncio.TimeoutError):
+            return {}
+        else:
+            return d
 
     async def factory_reset(self) -> dict:
         """Reset the miner to factory defaults.
@@ -647,6 +666,7 @@ class BTMinerAPI(BaseMinerAPI):
         )
 
     ### ADDED IN V2.0.5 Whatsminer API ###
+    @api_min_version("2.0.5")
     async def set_temp_offset(self, temp_offset: int):
         """Set the offset of miner hash board target temperature.
 
@@ -673,6 +693,7 @@ class BTMinerAPI(BaseMinerAPI):
 
         return await self.send_privileged_command("set_temp_offset", temp_offset=temp_offset)
 
+    @api_min_version("2.0.5")
     async def adjust_power_limit(self, power_limit: int):
         """Set the upper limit of the miner's power. Cannot be higher than the ordinary power of the machine.
 
@@ -694,6 +715,7 @@ class BTMinerAPI(BaseMinerAPI):
         return await self.send_privileged_command("adjust_power_limit", power_limit=power_limit)
 
 
+    @api_min_version("2.0.5")
     async def adjust_upfreq_speed(self, upfreq_speed: int):
         """Set the upfreq speed, 0 is the normal speed, 9 is the fastest speed.
 
@@ -720,6 +742,7 @@ class BTMinerAPI(BaseMinerAPI):
             )
         return await self.send_privileged_command("adjust_upfreq_speed", upfreq_speed=upfreq_speed)
 
+    @api_min_version("2.0.5")
     async def set_poweroff_cool(self, poweroff_cool: bool):
         """Set whether to cool the machine when mining is stopped.
 
@@ -739,6 +762,7 @@ class BTMinerAPI(BaseMinerAPI):
 
         return await self.send_privileged_command("set_poweroff_cool", poweroff_cool=int(poweroff_cool))
 
+    @api_min_version("2.0.5")
     async def set_fan_zero_speed(self, fan_zero_speed: bool):
         """Sets whether the fan speed supports the lowest 0 speed.
 
@@ -885,6 +909,7 @@ class BTMinerAPI(BaseMinerAPI):
         """
         return await self.send_command("get_miner_info", allow_warning=False)
 
+    @api_min_version("2.0.1")
     async def get_error_code(self) -> dict:
         """Get a list of error codes from the miner.
 

pyasic/API/cgminer.py

@@ -35,8 +35,10 @@ class CGMinerAPI(BaseMinerAPI):
         port: The port to reference the API on.  Default is 4028.
     """
 
-    def __init__(self, ip: str, port: int = 4028):
+    def __init__(self, ip: str, api_ver: str = "1.0.0", port: int = 4028):
         super().__init__(ip, port)
+        self.api_ver = api_ver
+
 
     async def multicommand(
         self, *commands: str, allow_warning: bool = True

pyasic/API/unknown.py

@@ -23,8 +23,10 @@ class UnknownAPI(BaseMinerAPI):
     with as many APIs as possible.
     """
 
-    def __init__(self, ip, port=4028):
+    def __init__(self, ip, api_ver: str = "1.0.0", port: int = 4028):
         super().__init__(ip, port)
+        self.api_ver = api_ver
+
 
     async def asccount(self) -> dict:
         return await self.send_command("asccount")

pyasic/data/__init__.py

@@ -42,6 +42,9 @@ class MinerData:
         ip: The IP of the miner as a str.
         datetime: The time and date this data was generated.
         model: The model of the miner as a str.
+        make: The make of the miner as a str.
+        api_ver: The current api version on the miner as a str.
+        fw_ver: The current firmware version on the miner as a str.
         hostname: The network hostname of the miner as a str.
         hashrate: The hashrate of the miner in TH/s as a float.
         left_board_hashrate: The hashrate of the left board of the miner in TH/s as a float.
@@ -83,6 +86,9 @@ class MinerData:
     datetime: datetime = None
     mac: str = "00:00:00:00:00:00"
     model: str = "Unknown"
+    make: str = "Unknown"
+    api_ver: str = "Unknown"
+    fw_ver: str = "Unknown"
     hostname: str = "Unknown"
     hashrate: float = 0
     hashboards: List[HashBoard] = field(default_factory=list)
@@ -123,6 +129,7 @@ class MinerData:
     fault_light: Union[bool, None] = None
     efficiency: int = field(init=False)
 
+
     @classmethod
     def fields(cls):
         return [f.name for f in fields(cls)]

pyasic/miners/_backends/__init__.py

@@ -17,3 +17,4 @@ from .bosminer import BOSMiner
 from .btminer import BTMiner
 from .cgminer import CGMiner
 from .hiveon import Hiveon
+from .cgminer_avalon import CGMinerAvalon

pyasic/miners/_backends/bmminer.py

@@ -27,11 +27,12 @@ from pyasic.settings import PyasicSettings
 class BMMiner(BaseMiner):
     """Base handler for BMMiner based miners."""
 
-    def __init__(self, ip: str) -> None:
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
         super().__init__(ip)
         self.ip = ipaddress.ip_address(ip)
-        self.api = BMMinerAPI(ip)
+        self.api = BMMinerAPI(ip, api_ver)
         self.api_type = "BMMiner"
+        self.api_ver = api_ver
         self.uname = "root"
         self.pwd = "admin"
 
@@ -167,6 +168,24 @@ class BMMiner(BaseMiner):
     async def fault_light_on(self) -> bool:
         return False
 
+    async def get_version(self) -> dict:
+        """Get miner firmware version.
+
+        Returns:
+            Miner api & firmware version or None.
+        """
+        # check if version is cached
+        if self.fw_ver and self.api_ver:
+            logging.debug(f"Found version for {self.ip}: {self.fw_ver}")
+            return {'api_ver': self.api_ver,'fw_ver': self.fw_ver}
+        # Now get the API version
+        version = await self.api.version()
+        self.api_ver = version['VERSION'][0]['API']
+        self.fw_ver = version['VERSION'][0]['CompileTime']
+        self.api.api_ver = self.api_ver
+        return {'api_ver': self.api_ver,'fw_ver': self.fw_ver}
+
+
     async def get_errors(self) -> List[MinerErrorData]:
         return []
 
@@ -211,6 +230,13 @@ class BMMiner(BaseMiner):
         if mac:
             data.mac = mac
 
+        if self.make:
+            data.make = self.make
+
+        await self.get_version()
+        data.api_ver = self.api_ver
+        data.fw_ver = self.fw_ver
+
         if errors:
             for error in errors:
                 data.errors.append(error)

pyasic/miners/_backends/bosminer.py

@@ -30,11 +30,12 @@ from pyasic.settings import PyasicSettings
 
 
 class BOSMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
         super().__init__(ip)
         self.ip = ipaddress.ip_address(ip)
-        self.api = BOSMinerAPI(ip)
+        self.api = BOSMinerAPI(ip, api_ver)
         self.api_type = "BOSMiner"
+        self.api_ver = api_ver
         self.uname = "root"
         self.pwd = "admin"
         self.config = None
@@ -228,21 +229,25 @@ class BOSMiner(BaseMiner):
         logging.warning(f"Failed to get model for miner: {self}")
         return None
 
-    async def get_version(self) -> Union[str, None]:
+    async def get_version(self) -> Union[dict, None]:
         """Get miner firmware version.
 
         Returns:
-            Miner firmware version or None.
+            Miner api & firmware version or None.
         """
         # check if version is cached
-        if self.version:
-            logging.debug(f"Found version for {self.ip}: {self.version}")
-            return self.version
+        if self.fw_ver and self.api_ver:
+            logging.debug(f"Found version for {self.ip}: {self.fw_ver}")
+            return {'api_ver': self.api_ver,'fw_ver': self.fw_ver}
         version_data = None
         # try to get data from graphql
         data = await self.send_graphql_query("{bos{info{version{full}}}}")
         if data:
-            version_data = data["bos"]["info"]["version"]["full"]
+            try:
+                version_data = data["bos"]["info"]["version"]["full"]
+            except KeyError:
+                version_data = data["data"]["bos"]["info"]["version"]["full"]
+
 
         if not version_data:
             # try version data file
@@ -250,9 +255,14 @@ class BOSMiner(BaseMiner):
 
         # if we get the version data, parse it
         if version_data:
-            self.version = version_data.split("-")[5]
-            logging.debug(f"Found version for {self.ip}: {self.version}")
-            return self.version
+            self.fw_ver = version_data.split("-")[5]
+            logging.debug(f"Found version for {self.ip}: {self.fw_ver}")
+
+            # Now get the API version
+            version = await self.api.version()
+            self.api_ver = version['VERSION'][0]['API']
+            self.api.api_ver = self.api_ver
+            return {'api_ver': self.api_ver,'fw_ver': self.fw_ver}
 
         # if we fail to get version, log a failed attempt
         logging.warning(f"Failed to get model for miner: {self}")
@@ -359,6 +369,7 @@ class BOSMiner(BaseMiner):
         model = await self.get_model()
         hostname = await self.get_hostname()
         mac = await self.get_mac()
+        await self.get_version()
 
         if model:
             data.model = model
@@ -369,6 +380,11 @@ class BOSMiner(BaseMiner):
         if mac:
             data.mac = mac
 
+        data.api_ver = self.api_ver
+        data.fw_ver = self.fw_ver
+
+        data.make = self.make
+
         data.fault_light = await self.check_light()
 
         miner_data = None
@@ -563,6 +579,12 @@ class BOSMiner(BaseMiner):
 
         data.mac = await self.get_mac()
         data.model = await self.get_model()
+        await self.get_version()
+
+        data.api_ver = self.api_ver
+        data.fw_ver = self.fw_ver
+        data.make = self.make
+
         if query_data.get("bos"):
             if query_data["bos"].get("hostname"):
                 data.hostname = query_data["bos"]["hostname"]

pyasic/miners/_backends/bosminer_old.py

@@ -24,10 +24,10 @@ from pyasic.miners.base import BaseMiner
 
 
 class BOSMinerOld(BaseMiner):
-    def __init__(self, ip: str) -> None:
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
         super().__init__(ip)
         self.ip = ipaddress.ip_address(ip)
-        self.api = BOSMinerAPI(ip)
+        self.api = BOSMinerAPI(ip, api_ver)
         self.api_type = "BOSMiner"
         self.uname = "root"
         self.pwd = "admin"

pyasic/miners/_backends/btminer.py

@@ -26,11 +26,12 @@ from pyasic.settings import PyasicSettings
 
 
 class BTMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
         super().__init__(ip)
         self.ip = ipaddress.ip_address(ip)
-        self.api = BTMinerAPI(ip)
+        self.api = BTMinerAPI(ip, api_ver)
         self.api_type = "BTMiner"
+        self.api_ver = api_ver
 
     async def get_model(self) -> Union[str, None]:
         """Get miner model.
@@ -137,12 +138,14 @@ class BTMiner(BaseMiner):
                     return True
         return False
 
-    async def fault_light_on(self) -> bool:
+    async def fault_light_on(self, flash: list = []) -> bool:
+        if flash == []:
+            # If no flash pattern is provided, use a red-green semi-slow alternating flash
+            flash = [{"color": "green", "start":0, "period":400, "duration":200},
+                     {"color": "red", "start":200, "period":400, "duration":200}]
         try:
-            data = await self.api.set_led(auto=False)
-            await self.api.set_led(
-                auto=False, color="green", start=0, period=1, duration=0
-            )
+            for x in flash:
+                data = await self.api.set_led(auto=False, **x)
         except APIError:
             return False
         if data:
@@ -289,33 +292,44 @@ class BTMiner(BaseMiner):
         if model:
             data.model = model
 
+        if self.make:
+            data.make = self.make
+
+        await self.get_version()
+        data.api_ver = self.api_ver
+        data.fw_ver = self.fw_ver
+
         if hostname:
             data.hostname = hostname
 
         data.fault_light = await self.check_light()
 
         miner_data = None
+        err_data = None
         for i in range(PyasicSettings().miner_get_data_retries):
             try:
                 miner_data = await self.api.multicommand("summary", "devs", "pools", allow_warning=allow_warning)
                 if miner_data:
                     break
+                else:
+                    err_data = await self.api.get_error_code()
             except APIError:
                 pass
-        if not miner_data:
+        if not (miner_data or err_data):
             return data
 
-        summary = miner_data.get("summary")[0]
-        devs = miner_data.get("devs")[0]
-        pools = miner_data.get("pools")[0]
+        summary = miner_data["summary"][0] if miner_data.get("summary") else None
+        devs = miner_data["devs"][0] if miner_data.get("devs") else None
+        pools = miner_data["pools"][0] if miner_data.get("pools") else None
         try:
             psu_data = await self.api.get_psu()
         except APIError:
             psu_data = None
-        try:
-            err_data = await self.api.get_error_code()
-        except APIError:
-            err_data = None
+        if not err_data:
+            try:
+                err_data = await self.api.get_error_code()
+            except APIError:
+                err_data = None
 
         if summary:
             summary_data = summary.get("SUMMARY")
@@ -334,8 +348,9 @@ class BTMiner(BaseMiner):
                     if summary_data[0].get("Power Fanspeed"):
                         data.fan_psu = summary_data[0]["Power Fanspeed"]
 
-                    data.fan_1 = summary_data[0]["Fan Speed In"]
-                    data.fan_2 = summary_data[0]["Fan Speed Out"]
+                    if self.fan_count > 0:
+                        data.fan_1 = summary_data[0]["Fan Speed In"]
+                        data.fan_2 = summary_data[0]["Fan Speed Out"]
 
                     hr = summary_data[0].get("MHS 1m")
                     if hr:
@@ -453,6 +468,23 @@ class BTMiner(BaseMiner):
 
         return data
 
+    async def get_version(self) -> Union[dict, bool]:
+        """Get miner firmware version.
+
+        Returns:
+            Miner api & firmware version or None.
+        """
+        # Check to see if the version info is already cached
+        if self.api_ver and self.fw_ver:
+            return {"api_ver": self.api_ver, "fw_ver": self.fw_ver}
+        data = await self.api.get_version()
+        if "Code" in data.keys():
+            if data["Code"] == 131:
+                self.api_ver = data["Msg"]["api_ver"].replace("whatsminer v", "")
+                self.fw_ver = data["Msg"]["fw_ver"]
+            self.api.api_ver = self.api_ver
+            return {"api_ver": self.api_ver, "fw_ver": self.fw_ver}
+        return False
 
     async def set_power_limit(self, wattage: int) -> bool:
         try:

pyasic/miners/_backends/cgminer.py

@@ -26,10 +26,11 @@ from pyasic.settings import PyasicSettings
 
 
 class CGMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
         super().__init__(ip)
         self.ip = ipaddress.ip_address(ip)
-        self.api = CGMinerAPI(ip)
+        self.api = CGMinerAPI(ip, api_ver)
+        self.api_ver = api_ver
         self.api_type = "CGMiner"
         self.uname = "root"
         self.pwd = "admin"
@@ -170,6 +171,23 @@ class CGMiner(BaseMiner):
     async def get_mac(self) -> str:
         return "00:00:00:00:00:00"
 
+    async def get_version(self) -> dict:
+        """Get miner firmware version.
+
+        Returns:
+            Miner api & firmware version or None.
+        """
+        # check if version is cached
+        if self.fw_ver and self.api_ver:
+            logging.debug(f"Found version for {self.ip}: {self.fw_ver}")
+            return {'api_ver': self.api_ver,'fw_ver': self.fw_ver}
+        # Now get the API version
+        version = await self.api.version()
+        self.api_ver = version['VERSION'][0]['API']
+        self.fw_ver = version['VERSION'][0]['CGMiner']
+        self.api.api_ver = self.api_ver
+        return {'api_ver': self.api_ver,'fw_ver': self.fw_ver}
+
     async def get_data(self, allow_warning: bool = False) -> MinerData:
         """Get data from the miner.
 

pyasic/miners/_backends/cgminer_avalon.py

@@ -0,0 +1,276 @@
+#  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 ipaddress
+import logging
+from typing import List, Union
+
+from pyasic.API.cgminer import CGMinerAPI
+from pyasic.config import MinerConfig
+from pyasic.data import HashBoard, MinerData
+from pyasic.data.error_codes import MinerErrorData
+from pyasic.errors import APIError
+from pyasic.miners.base import BaseMiner
+from pyasic.settings import PyasicSettings
+from pyasic.miners._backends import CGMiner
+
+
+class CGMinerAvalon(CGMiner):
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver)
+        self.ip = ip
+
+    async def check_light(self) -> bool:
+        if self.light:
+            return self.light
+        data = await self.api.ascset(0, "led", "1-255")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set info: LED[1]":
+            return True
+        return False
+
+    async def fault_light_on(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-1")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def fault_light_off(self) -> bool:
+        data = await self.api.ascset(0, "led", "1-0")
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
+    async def reboot(self) -> bool:
+        if (await self.api.restart())["STATUS"] == "RESTART":
+            return True
+        return False
+
+    async def stop_mining(self) -> bool:
+        return False
+
+    async def resume_mining(self) -> bool:
+        return False
+
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        """Configures miner with yaml config."""
+        raise NotImplementedError
+        logging.debug(f"{self}: Sending config.")
+        conf = config.as_avalon(user_suffix=user_suffix)
+        data = await self.api.ascset(
+            0, "setpool", f"root,root,{conf}"
+        )  # this should work but doesn't
+        return data
+
+    async def get_mac(self) -> str:
+        mac = None
+        version = await self.api.version()
+        if version:
+            if "VERSION" in version.keys():
+                if "MAC" in version["VERSION"][0].keys():
+                    base_mac = version["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+        return mac
+
+    async def get_data(self, allow_warning: bool = True):
+        data = MinerData(
+            ip=str(self.ip),
+            ideal_chips=self.nominal_chips * self.ideal_hashboards,
+            ideal_hashboards=self.ideal_hashboards,
+            hashboards=[
+                HashBoard(slot=i, expected_chips=self.nominal_chips)
+                for i in range(self.ideal_hashboards)
+            ],
+        )
+
+        model = await self.get_model()
+        mac = None
+
+        if model:
+            data.model = model
+
+        if self.make:
+            data.make = self.make
+
+        await self.get_version()
+        data.api_ver = self.api_ver
+        data.fw_ver = self.fw_ver
+
+        data.fault_light = await self.check_light()
+
+        miner_data = None
+        for i in range(PyasicSettings().miner_get_data_retries):
+            miner_data = await self.api.multicommand(
+                "version", "summary", "pools", "stats", allow_warning=allow_warning
+            )
+            if miner_data:
+                break
+        if not miner_data:
+            hostname = await self.get_hostname()
+            mac = await self.get_mac()
+
+            if hostname and not hostname == "?":
+                data.hostname = hostname
+            elif mac:
+                data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+            if mac:
+                data.mac = mac
+            return data
+
+        summary = miner_data.get("summary")
+        version = miner_data.get("version")
+        pools = miner_data.get("pools")
+        stats = miner_data.get("stats")
+
+        if summary:
+            hr = summary[0].get("SUMMARY")
+            if hr:
+                if len(hr) > 0:
+                    hr = hr[0].get("MHS 1m")
+                    if hr:
+                        data.hashrate = round(hr / 1000000, 2)
+
+        if version:
+            if "VERSION" in version[0].keys():
+                if "MAC" in version[0]["VERSION"][0].keys():
+                    base_mac = version[0]["VERSION"][0]["MAC"].upper()
+                    # parse the MAC into a recognizable form
+                    mac = ":".join(
+                        [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
+                    )
+
+        if stats:
+            stats_data = stats[0].get("STATS")
+            if stats_data:
+                for key in stats_data[0].keys():
+                    if key.startswith("MM ID"):
+                        raw_data = self.parse_stats(stats_data[0][key])
+                        for fan in range(self.fan_count):
+                            if f"Fan{fan+1}" in raw_data:
+                                setattr(
+                                    data,
+                                    f"fan_{fan+1}",
+                                    int(raw_data[f"Fan{fan+1}"]),
+                                )
+                        for board in range(self.ideal_hashboards):
+                            chip_temp = raw_data.get("MTmax")
+                            if chip_temp:
+                                data.hashboards[board].chip_temp = chip_temp[board]
+
+                            temp = raw_data.get("MTavg")
+                            if temp:
+                                data.hashboards[board].temp = temp[board]
+
+                            chips = raw_data.get(f"PVT_T{board}")
+                            if chips:
+                                data.hashboards[board].chips = len(
+                                    [item for item in chips if not item == "0"]
+                                )
+
+        if pools:
+            pool_1 = None
+            pool_2 = None
+            pool_1_user = None
+            pool_2_user = None
+            pool_1_quota = 1
+            pool_2_quota = 1
+            quota = 0
+            for pool in pools[0].get("POOLS"):
+                if not pool_1_user:
+                    pool_1_user = pool.get("User")
+                    pool_1 = pool["URL"]
+                    pool_1_quota = pool["Quota"]
+                elif not pool_2_user:
+                    pool_2_user = pool.get("User")
+                    pool_2 = pool["URL"]
+                    pool_2_quota = pool["Quota"]
+                if not pool.get("User") == pool_1_user:
+                    if not pool_2_user == pool.get("User"):
+                        pool_2_user = pool.get("User")
+                        pool_2 = pool["URL"]
+                        pool_2_quota = pool["Quota"]
+            if pool_2_user and not pool_2_user == pool_1_user:
+                quota = f"{pool_1_quota}/{pool_2_quota}"
+
+            if pool_1:
+                pool_1 = pool_1.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_1_url = pool_1
+
+            if pool_1_user:
+                data.pool_1_user = pool_1_user
+
+            if pool_2:
+                pool_2 = pool_2.replace("stratum+tcp://", "").replace(
+                    "stratum2+tcp://", ""
+                )
+                data.pool_2_url = pool_2
+
+            if pool_2_user:
+                data.pool_2_user = pool_2_user
+
+            if quota:
+                data.pool_split = str(quota)
+
+        hostname = await self.get_hostname()
+
+        if mac:
+            data.mac = mac
+        else:
+            mac = await self.get_mac()
+            if mac:
+                data.mac = mac
+        if hostname and not hostname == "?":
+            data.hostname = hostname
+        elif mac:
+            data.hostname = f"Avalon{mac.replace(':', '')[-6:]}"
+
+        return data
+
+    @staticmethod
+    def parse_stats(stats):
+        _stats_items = re.findall(".+?\[*?]", stats)
+        stats_items = []
+        stats_dict = {}
+        for item in _stats_items:
+            if ":" in item:
+                data = item.replace("]", "").split("[")
+                data_list = [i.split(": ") for i in data[1].strip().split(", ")]
+                data_dict = {}
+                for key, val in [tuple(item) for item in data_list]:
+                    data_dict[key] = val
+                raw_data = [data[0].strip(), data_dict]
+            else:
+                raw_data = [
+                    value
+                    for value in item.replace("[", " ")
+                    .replace("]", " ")
+                    .split(" ")[:-1]
+                    if value != ""
+                ]
+                if len(raw_data) == 1:
+                    raw_data.append("")
+            if raw_data[0] == "":
+                raw_data = raw_data[1:]
+
+            if len(raw_data) == 2:
+                stats_dict[raw_data[0]] = raw_data[1]
+            else:
+                stats_dict[raw_data[0]] = raw_data[1:]
+            stats_items.append(raw_data)
+
+        return stats_dict

pyasic/miners/_backends/hiveon.py

@@ -18,8 +18,8 @@ from pyasic.miners._backends import BMMiner
 
 
 class Hiveon(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver)
         self.ip = ipaddress.ip_address(ip)
         self.api_type = "Hiveon"
         self.uname = "root"

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S17(BaseMiner):  # noqa - ignore ABC method implementation
+class S17(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S17Plus(BaseMiner):  # noqa - ignore ABC method implementation
+class S17Plus(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S17Pro(BaseMiner):  # noqa - ignore ABC method implementation
+class S17Pro(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S17e(BaseMiner):  # noqa - ignore ABC method implementation
+class S17e(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class T17(BaseMiner):  # noqa - ignore ABC method implementation
+class T17(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class T17Plus(BaseMiner):  # noqa - ignore ABC method implementation
+class T17Plus(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class T17e(BaseMiner):  # noqa - ignore ABC method implementation
+class T17e(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19(BaseMiner):  # noqa - ignore ABC method implementation
+class S19(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19Pro(BaseMiner):  # noqa - ignore ABC method implementation
+class S19Pro(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19XP(BaseMiner):  # noqa - ignore ABC method implementation
+class S19XP(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19a(BaseMiner):  # noqa - ignore ABC method implementation
+class S19a(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19aPro(BaseMiner):  # noqa - ignore ABC method implementation
+class S19aPro(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19j(BaseMiner):  # noqa - ignore ABC method implementation
+class S19j(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S19jPro(BaseMiner):  # noqa - ignore ABC method implementation
+class S19jPro(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,10 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
 
-class T19(BaseMiner):  # noqa - ignore ABC method implementation
+class T19(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S9(BaseMiner):  # noqa - ignore ABC method implementation
+class S9(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class S9i(BaseMiner):  # noqa - ignore ABC method implementation
+class S9i(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AntMiner
 
-
-class T9(BaseMiner):  # noqa - ignore ABC method implementation
+class T9(AntMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon1026(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon1026(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon1047(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon1047(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon1066(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon1066(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon721(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon721(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon741(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon741(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon761(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon761(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon821(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon821(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon841(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon841(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon851(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon851(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import AvalonMiner
 
-
-class Avalon921(BaseMiner):  # noqa - ignore ABC method implementation
+class Avalon921(AvalonMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import InnosiliconMiner
 
-
-class InnosiliconT3HPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class InnosiliconT3HPlus(InnosiliconMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str) -> None:
         super().__init__()
         self.ip = ip

pyasic/miners/_types/makes.py

@@ -0,0 +1,35 @@
+#  Copyright 2022 Upstream Data Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from pyasic.miners.base import BaseMiner
+
+class WhatsMiner(BaseMiner):  # noqa - ignore ABC method implementation
+    def __init__(self):
+        super().__init__()
+        self.make = "WhatsMiner"
+
+class AntMiner(BaseMiner):  # noqa - ignore ABC method implementation
+    def __init__(self):
+        super().__init__()
+        self.make = "AntMiner"
+
+class AvalonMiner(BaseMiner):  # noqa - ignore ABC method implementation
+    def __init__(self):
+        super().__init__()
+        self.make = "AvalonMiner"
+
+class InnosiliconMiner(BaseMiner):  # noqa - ignore ABC method implementation
+    def __init__(self):
+        super().__init__()
+        self.make = "Innosilicon"

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M20(BaseMiner):  # noqa - ignore ABC method implementation
+class M20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M20(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M20V10(BaseMiner):  # noqa - ignore ABC method implementation
+class M20V10(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M20S(BaseMiner):  # noqa - ignore ABC method implementation
+class M20S(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M20S(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M20SV10(BaseMiner):  # noqa - ignore ABC method implementation
+class M20SV10(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -33,7 +32,7 @@ class M20SV10(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M20SV20(BaseMiner):  # noqa - ignore ABC method implementation
+class M20SV20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M20SPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class M20SPlus(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M21(BaseMiner):  # noqa - ignore ABC method implementation
+class M21(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M21S(BaseMiner):  # noqa - ignore ABC method implementation
+class M21S(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M21S(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M21SV60(BaseMiner):  # noqa - ignore ABC method implementation
+class M21SV60(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -33,7 +32,7 @@ class M21SV60(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M21SV20(BaseMiner):  # noqa - ignore ABC method implementation
+class M21SV20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M21SPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class M21SPlus(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M30S(BaseMiner):  # noqa - ignore ABC method implementation
+class M30S(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M30S(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SV50(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SV50(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -33,7 +32,7 @@ class M30SV50(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SVG20(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SVG20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -42,7 +41,7 @@ class M30SVG20(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SVE20(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SVE20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -51,7 +50,7 @@ class M30SVE20(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SVE10(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SVE10(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M30SPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlus(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M30SPlus(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SPlusVG60(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusVG60(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -32,7 +31,7 @@ class M30SPlusVG60(BaseMiner):  # noqa - ignore ABC method implementation
         self.nominal_chips = 86
         self.fan_count = 2
 
-class M30SPlusVG40(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -41,7 +40,7 @@ class M30SPlusVG40(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SPlusVE40(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusVE40(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -50,7 +49,7 @@ class M30SPlusVE40(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SPlusVF20(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusVF20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M30SPlusPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusPlus(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M30SPlusPlus(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SPlusPlusVG30(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusPlusVG30(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -33,7 +32,7 @@ class M30SPlusPlusVG30(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SPlusPlusVG40(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusPlusVG40(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -42,7 +41,7 @@ class M30SPlusPlusVG40(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M30SPlusPlusVH60(BaseMiner):  # noqa - ignore ABC method implementation
+class M30SPlusPlusVH60(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M31S(BaseMiner):  # noqa - ignore ABC method implementation
+class M31S(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M31S(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SV10(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SV10(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -32,7 +31,7 @@ class M31SV10(BaseMiner):  # noqa - ignore ABC method implementation
         self.nominal_chips = 105
         self.fan_count = 2
 
-class M31SV20(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SV20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -40,7 +39,7 @@ class M31SV20(BaseMiner):  # noqa - ignore ABC method implementation
         self.nominal_chips = 111
         self.fan_count = 2
 
-class M31SV60(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SV60(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -49,7 +48,7 @@ class M31SV60(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SV70(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SV70(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M31SPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlus(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M31SPlus(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SPlusVE20(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlusVE20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -33,7 +32,7 @@ class M31SPlusVE20(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SPlusV30(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlusV30(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -42,7 +41,7 @@ class M31SPlusV30(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SPlusV40(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlusV40(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -51,7 +50,7 @@ class M31SPlusV40(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SPlusV60(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlusV60(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -60,7 +59,7 @@ class M31SPlusV60(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SPlusV80(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlusV80(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -69,7 +68,7 @@ class M31SPlusV80(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M31SPlusV90(BaseMiner):  # noqa - ignore ABC method implementation
+class M31SPlusV90(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M32(BaseMiner):  # noqa - ignore ABC method implementation
+class M32(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +23,7 @@ class M32(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M32V20(BaseMiner):  # noqa - ignore ABC method implementation
+class M32V20(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M32S(BaseMiner):  # noqa - ignore ABC method implementation
+class M32S(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
-
-class M34SPlus(BaseMiner):  # noqa - ignore ABC method implementation
+class M34SPlus(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -25,7 +24,7 @@ class M34SPlus(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 0
 
 
-class M34SPlusVE10(BaseMiner):  # noqa - ignore ABC method implementation
+class M34SPlusVE10(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

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

@@ -12,10 +12,10 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pyasic.miners.base import BaseMiner
+from pyasic.miners._types.makes import WhatsMiner
 
 
-class M50(BaseMiner):  # noqa - ignore ABC method implementation
+class M50(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip
@@ -24,7 +24,7 @@ class M50(BaseMiner):  # noqa - ignore ABC method implementation
         self.fan_count = 2
 
 
-class M50VH50(BaseMiner):  # noqa - ignore ABC method implementation
+class M50VH50(WhatsMiner):  # noqa - ignore ABC method implementation
     def __init__(self, ip: str):
         super().__init__()
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/S17.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerS17(BMMinerX17, S17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/S17_Plus.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerS17Plus(BMMinerX17, S17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/S17_Pro.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerS17Pro(BMMinerX17, S17Pro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/S17e.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerS17e(BMMinerX17, S17e):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/T17.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerT17(BMMinerX17, T17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/T17_Plus.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerT17Plus(BMMinerX17, T17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/T17e.py

@@ -18,6 +18,6 @@ from .X17 import BMMinerX17
 
 
 class BMMinerT17e(BMMinerX17, T17e):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X17/X17.py

@@ -21,8 +21,8 @@ from pyasic.settings import PyasicSettings
 
 
 class BMMinerX17(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip
         self.uname = "root"
         self.pwd = PyasicSettings().global_x17_password

pyasic/miners/antminer/bmminer/X19/S19.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19(BMMinerX19, S19):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/S19_Pro.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19Pro(BMMinerX19, S19Pro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/S19_XP.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19XP(BMMinerX19, S19XP):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/S19a.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19a(BMMinerX19, S19a):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/S19a_Pro.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19aPro(BMMinerX19, S19aPro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/S19j.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19j(BMMinerX19, S19j):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/S19j_Pro.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerS19jPro(BMMinerX19, S19jPro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/T19.py

@@ -18,6 +18,6 @@ from .X19 import BMMinerX19
 
 
 class BMMinerT19(BMMinerX19, T19):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X19/X19.py

@@ -25,8 +25,8 @@ from pyasic.settings import PyasicSettings
 
 
 class BMMinerX19(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip
         self.uname = "root"
         self.pwd = PyasicSettings().global_x19_password

pyasic/miners/antminer/bmminer/X9/S9.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S9  # noqa - Ignore access to _module
 
 
 class BMMinerS9(BMMiner, S9):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bmminer/X9/S9i.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S9i  # noqa - Ignore access to _module
 
 
 class BMMinerS9i(BMMiner, S9i):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

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

@@ -17,6 +17,6 @@ from pyasic.miners._types import T9  # noqa - Ignore access to _module
 
 
 class BMMinerT9(BMMiner, T9):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/S17.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17  # noqa - Ignore access to _module
 
 
 class BOSMinerS17(BOSMiner, S17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/S17_Plus.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17Plus  # noqa - Ignore access to _module
 
 
 class BOSMinerS17Plus(BOSMiner, S17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/S17_Pro.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17Pro  # noqa - Ignore access to _module
 
 
 class BOSMinerS17Pro(BOSMiner, S17Pro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/S17e.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17e  # noqa - Ignore access to _module
 
 
 class BOSMinerS17e(BOSMiner, S17e):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/T17.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T17  # noqa - Ignore access to _module
 
 
 class BOSMinerT17(BOSMiner, T17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/T17_Plus.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T17Plus  # noqa - Ignore access to _module
 
 
 class BOSMinerT17Plus(BOSMiner, T17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X17/T17e.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T17e  # noqa - Ignore access to _module
 
 
 class BOSMinerT17e(BOSMiner, T17e):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X19/S19.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S19  # noqa - Ignore access to _module
 
 
 class BOSMinerS19(BOSMiner, S19):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X19/S19_Pro.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S19Pro  # noqa - Ignore access to _module
 
 
 class BOSMinerS19Pro(BOSMiner, S19Pro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X19/S19j.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S19j  # noqa - Ignore access to _module
 
 
 class BOSMinerS19j(BOSMiner, S19j):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X19/S19j_Pro.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S19jPro  # noqa - Ignore access to _module
 
 
 class BOSMinerS19jPro(BOSMiner, S19jPro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X19/T19.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T19  # noqa - Ignore access to _module
 
 
 class BOSMinerT19(BOSMiner, T19):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/bosminer/X9/S9.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S9  # noqa - Ignore access to _module
 
 
 class BOSMinerS9(BOSMiner, S9):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/S17.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17  # noqa - Ignore access to _module
 
 
 class CGMinerS17(CGMiner, S17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/S17_Plus.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17Plus  # noqa - Ignore access to _module
 
 
 class CGMinerS17Plus(CGMiner, S17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/S17_Pro.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17Pro  # noqa - Ignore access to _module
 
 
 class CGMinerS17Pro(CGMiner, S17Pro):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/S17e.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import S17e  # noqa - Ignore access to _module
 
 
 class CGMinerS17e(CGMiner, S17e):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/T17.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T17  # noqa - Ignore access to _module
 
 
 class CGMinerT17(CGMiner, T17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/T17_Plus.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T17Plus  # noqa - Ignore access to _module
 
 
 class CGMinerT17Plus(CGMiner, T17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip

pyasic/miners/antminer/cgminer/X17/T17e.py

@@ -17,6 +17,6 @@ from pyasic.miners._types import T17e  # noqa - Ignore access to _module
 
 
 class CGMinerT17e(CGMiner, T17e):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
+    def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
+        super().__init__(ip, api_ver=api_ver)
         self.ip = ip