bump version number

# Conflicts:
#	pyproject.toml

.dockerignore

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

README.md

@@ -2,16 +2,21 @@
 *A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH.*
 
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-
+[![Code style: black](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![Code style: black](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
 ## Usage
+
+### Standard Usage
+You can install pyasic directly from pip with the command `pip install pyasic`
+
+For those of you who aren't comfortable with code and developer tools, there are windows builds of GUI applications that use this library here -> (https://drive.google.com/drive/folders/1DjR8UOS_g0ehfiJcgmrV0FFoqFvE9akW?usp=sharing)
+
+### Developers
 To use this repo, first download it, create a virtual environment, enter the virtual environment, and install relevant packages by navigating to this directory and running ```pip install -r requirements.txt``` on Windows or ```pip3 install -r requirements.txt``` on Mac or UNIX if the first command fails.
 
 You can also use poetry by initializing and running ```poetry install```
 
-For those of you who aren't comfortable with code and developer tools, there are windows builds of the GUI applications here -> (https://drive.google.com/drive/folders/1DjR8UOS_g0ehfiJcgmrV0FFoqFvE9akW?usp=sharing)
-
 ### Interfacing with miners programmatically
-<br>
 
 ##### Note: If you are trying to interface with Whatsminers, there is a bug in the way they are interacted with on Windows, so to fix that you need to change the event loop policy using this code: 
 ```python
@@ -31,228 +36,130 @@ To write your own custom programs with this repo, you have many options.
 
 It is recommended that you explore the files in this repo to familiarize yourself with them, try starting with the miners module and going from there.
 
-A basic script to find all miners on the network and get the hashrate from them looks like this -
+There are 2 main ways to get a miner and it's functions via scanning or via the MinerFactory.
 
+#### Scanning for miners
 ```python
 import asyncio
+import sys
+
 from pyasic.network import MinerNetwork
 
+# Fix whatsminer bug
+# if the computer is windows, set the event loop policy to a WindowsSelector policy
+if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
-async def get_hashrate():
-    # Miner Network class allows for easy scanning of a network
-    # Give it any IP on a network and it will find the whole subnet
-    # It can also be passed a subnet mask:
-    # miner_network = MinerNetwork('192.168.1.55', mask=23)
-    miner_network = MinerNetwork('192.168.1.1')
-    # Miner Network scan function returns Miner classes for all miners found
-    miners = await miner_network.scan_network_for_miners()
-    # Each miner will return with its own set of functions, and an API class instance
+
+# define asynchronous function to scan for miners
+async def scan_and_get_data():
+    # Define network range to be used for scanning
+    # This can take a list of IPs, a constructor string, or an IP and subnet mask
+    # The standard mask is /24, and you can pass any IP address in the subnet
+    net = MinerNetwork("192.168.1.69", mask=24)
+    # Scan the network for miners
+    # This function returns a list of miners of the correct type as a class
+    miners: list = await net.scan_network_for_miners()
+    
+    # We can now get data from any of these miners
+    # To do them all we have to create a list of tasks and gather them
     tasks = [miner.get_data() for miner in miners]
     # Gather all tasks asynchronously and run them
     data = await asyncio.gather(*tasks)
-    # now we have a list of MinerData, and can get .hashrate
-    print([item.hashrate for item in data])
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_hashrate())
+    
+    # Data is now a list of MinerData, and we can reference any part of that
+    # Print out all data for now
+    for item in data:
+        print(item)
+      
+if __name__ == "__main__":
+    asyncio.run(scan_and_get_data())
 ```
-<br>
-You can also create your own miner without scanning if you know the IP:
 
+</br>
+
+#### Getting a miner if you know the IP
 ```python
 import asyncio
-import ipaddress
-from pyasic.miners.miner_factory import Mine~~~~rFactory
+import sys
+
+from pyasic.miners.miner_factory import MinerFactory
+
+# Fix whatsminer bug
+# if the computer is windows, set the event loop policy to a WindowsSelector policy
+if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 
-async def get_miner_hashrate(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
+# define asynchronous function to get miner and data
+async def get_miner_data(miner_ip: str):
+    # Use MinerFactory to get miner
+    # MinerFactory is a singleton, so we can just get the instance in place
+    miner = await MinerFactory().get_miner(miner_ip)
+    
+    # Get data from the miner
     data = await miner.get_data()
-    # print out hashrate
-    print(data.hashrate)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_hashrate(str("192.168.1.69")))
-```
-
-
-Now that you know that, lets move on to some common API functions that you might want to use.
-
-### Common commands:
-* Get the data used by the config utility, this includes pool data, wattage use, temperature, hashrate, etc:
-* All the data from below commands and more are returned from this in a consistent dataclass.  Check out the `MinerData` class in  `/data/__init__.py` for more information.
-
-```python
-import asyncio
-import ipaddress
-from pyasic.miners.miner_factory import MinerFactory
-
-
-async def get_miner_pool_data(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the data
-    data = await miner.get_data()
-
     print(data)
 
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_pool_data(str("192.168.1.69")))
+if __name__ == "__main__":
+    asyncio.run(get_miner_data("192.168.1.69"))
 ```
 
+### Advanced data gathering
+
+If needed, this library exposes a wrapper for the miner API that can be used for advanced data gathering.
+
+#### List available API commands
+```python
+import asyncio
+import sys
+
+from pyasic.miners.miner_factory import MinerFactory
+
+# Fix whatsminer bug
+# if the computer is windows, set the event loop policy to a WindowsSelector policy
+if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 
-* Getting pool data:
+async def get_api_commands(miner_ip: str):
+    # Get the miner
+    miner = await MinerFactory().get_miner(miner_ip)
+    
+    # List all available commands
+    print(miner.api.get_commands())
+    
+    
+if __name__ == "__main__":
+    asyncio.run(get_api_commands("192.168.1.69"))
+```
+
+#### Use miner API commands to gather data
+
+The miner API commands will raise an `APIError` if they fail with a bad status code, to bypass this you must send them manually by using `miner.api.send_command(command, ignore_errors=True)`
 
 ```python
 import asyncio
-import ipaddress
+import sys
+
 from pyasic.miners.miner_factory import MinerFactory
 
-
-async def get_miner_pool_data(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    pools = await miner.api.pools()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = pools["POOLS"]
-    # parse further from here to get all the pool info you want.
-    # each pool is on a different index eg:
-    # data[0] is pool 1
-    # data[1] is pool 2
-    # etc
-    print(data)
+# Fix whatsminer bug
+# if the computer is windows, set the event loop policy to a WindowsSelector policy
+if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_pool_data(str("192.168.1.69")))
-```
-
-* Getting temperature data:
-
-This one is a bit tougher, lots of miners do this a different way, you might need to experiment a bit to find what works for you.
-BraiinsOS uses the "temps" command, Whatsminers has it in "devs", Avalonminers put it in "stats" as well as some other miners,
-but the spot I like to try first is in "summary".
-
-A pretty good example of really trying to make this robust is in ```cfg_util.func.miners``` in the ```get_formatted_data()``` function.
-
-```python
-import asyncio
-import ipaddress
-from pyasic.miners.miner_factory import MinerFactory
-
-
-async def get_miner_temperature_data(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    summary = await miner.api.summary()
-
-    data = summary['SUMMARY'][0]["Temperature"]
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_temperature_data(str("192.168.1.69")))
-```
-
-* Getting power data:
-
-How about data on the power usage of the miner?  This one only works for Whatsminers and BraiinsOS for now, and the Braiins one just uses the tuning setting, but its good enough for basic uses.
-
-```python
-import asyncio
-import ipaddress
-from pyasic.miners.miner_factory import MinerFactory
-
-
-async def get_miner_power_data(ip: str):
-    data = None
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # check if this can be sent the "tunerstatus" command, BraiinsOS only
-    if "tunerstatus" in miner.api.get_commands():
-        # send the command
-        tunerstatus = await miner.api.tunerstatus()
-        # parse the return
-        data = tunerstatus['TUNERSTATUS'][0]["PowerLimit"]
-    else:
-        # send the command
-        # whatsminers have the power info in summary
-        summary = await miner.api.summary()
-        # parse the return
-        data = summary['SUMMARY'][0]["Power"]
-
-    if data:
-        print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_power_data(str("192.168.1.69")))
-```
-
-* Multicommands:
-
-Multicommands make it much easier to get many types of data all at once.  The multicommand function will also remove any commands that your API can't handle automatically.
-How about we get the current pool user and hashrate in 1 command?
-
-```python
-import asyncio
-import ipaddress
-from pyasic.miners.miner_factory import MinerFactory
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_hashrate_and_pool(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    api_data = await miner.api.multicommand("pools", "summary")
-    if "pools" in api_data.keys():
-        user = api_data["pools"][0]["POOLS"][0]["User"]
-        print(user)
-    if "summary" in api_data.keys():
-        hashrate = api_data["summary"][0]["SUMMARY"][0]["MHS av"]
-        print(hashrate)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_hashrate_and_pool(str("192.168.1.9")))
+async def get_api_commands(miner_ip: str):
+    # Get the miner
+    miner = await MinerFactory().get_miner(miner_ip)
+    
+    # Run the devdetails command
+    # This is equivalent to await miner.api.send_command("devdetails")
+    devdetails: dict = await miner.api.devdetails()
+    print(devdetails)
+    
+    
+if __name__ == "__main__":
+    asyncio.run(get_api_commands("192.168.1.69"))
 ```

pyasic/data/__init__.py

@@ -40,6 +40,9 @@ class MinerData:
     model: str = "Unknown"
     hostname: str = "Unknown"
     hashrate: float = 0
+    left_board_hashrate: float = 0
+    center_board_hashrate: float = 0
+    right_board_hashrate: float = 0
     temperature_avg: int = field(init=False)
     env_temp: float = 0
     left_board_temp: int = 0

pyasic/miners/_backends/bmminer.py

@@ -186,6 +186,16 @@ class BMMiner(BaseMiner):
                     data.center_chips = boards[1].get(f"chain_acn{board_offset+1}")
                     data.right_chips = boards[1].get(f"chain_acn{board_offset+2}")
 
+                    data.left_board_hashrate = round(
+                        float(boards[1].get(f"chain_rate{board_offset}")) / 1000, 2
+                    )
+                    data.center_board_hashrate = round(
+                        float(boards[1].get(f"chain_rate{board_offset+1}")) / 1000, 2
+                    )
+                    data.right_board_hashrate = round(
+                        float(boards[1].get(f"chain_rate{board_offset+2}")) / 1000, 2
+                    )
+
         if stats:
             temp = stats.get("STATS")
             if temp:

pyasic/miners/_backends/bosminer.py

@@ -286,12 +286,18 @@ class BOSMiner(BaseMiner):
         for i in range(DATA_RETRIES):
             try:
                 miner_data = await self.api.multicommand(
-                    "summary", "temps", "tunerstatus", "pools", "devdetails", "fans"
+                    "summary",
+                    "temps",
+                    "tunerstatus",
+                    "pools",
+                    "devdetails",
+                    "fans",
+                    "devs",
                 )
             except APIError as e:
                 if str(e.message) == "Not ready":
                     miner_data = await self.api.multicommand(
-                        "summary", "tunerstatus", "pools", "fans"
+                        "summary", "tunerstatus", "pools", "fans", "devs"
                     )
             if miner_data:
                 break
@@ -302,6 +308,7 @@ class BOSMiner(BaseMiner):
         tunerstatus = miner_data.get("tunerstatus")
         pools = miner_data.get("pools")
         devdetails = miner_data.get("devdetails")
+        devs = miner_data.get("devs")
         fans = miner_data.get("fans")
 
         if summary:
@@ -399,6 +406,20 @@ class BOSMiner(BaseMiner):
                         chips = board["Chips"]
                         setattr(data, board_map[_id], chips)
 
+        if devs:
+            boards = devs[0].get("DEVS")
+            if boards:
+                if len(boards) > 0:
+                    board_map = {
+                        0: "left_board_hashrate",
+                        1: "center_board_hashrate",
+                        2: "right_board_hashrate",
+                    }
+                    offset = 6 if boards[0]["ID"] in [6, 7, 8] else boards[0]["ID"]
+                    for board in boards:
+                        _id = board["ID"] - offset
+                        hashrate = board["MHS 1m"]
+                        setattr(data, board_map[_id], hashrate)
         return data
 
     async def get_mac(self):

pyasic/miners/_backends/btminer.py

@@ -144,12 +144,16 @@ class BTMiner(BaseMiner):
             summary_data = summary.get("SUMMARY")
             if summary_data:
                 if len(summary_data) > 0:
+                    wattage_limit = None
                     if summary_data[0].get("MAC"):
                         mac = summary_data[0]["MAC"]
 
                     if summary_data[0].get("Env Temp"):
                         data.env_temp = summary_data[0]["Env Temp"]
 
+                    if summary_data[0].get("Power Limit"):
+                        wattage_limit = summary_data[0]["Power Limit"]
+
                     data.fan_1 = summary_data[0]["Fan Speed In"]
                     data.fan_2 = summary_data[0]["Fan Speed Out"]
 
@@ -160,7 +164,11 @@ class BTMiner(BaseMiner):
                     wattage = summary_data[0].get("Power")
                     if wattage:
                         data.wattage = round(wattage)
-                        data.wattage_limit = round(wattage)
+
+                        if not wattage_limit:
+                            wattage_limit = round(wattage)
+
+                    data.wattage_limit = wattage_limit
 
         if devs:
             temp_data = devs.get("DEVS")
@@ -170,8 +178,10 @@ class BTMiner(BaseMiner):
                     _id = board["ASC"]
                     chip_temp = round(board["Chip Temp Avg"])
                     board_temp = round(board["Temperature"])
+                    hashrate = round(board["MHS 1m"] / 1000000, 2)
                     setattr(data, f"{board_map[_id]}_chip_temp", chip_temp)
                     setattr(data, f"{board_map[_id]}_temp", board_temp)
+                    setattr(data, f"{board_map[_id]}_hashrate", hashrate)
 
         if devs:
             boards = devs.get("DEVS")

pyasic/miners/_backends/cgminer.py

@@ -111,6 +111,9 @@ class CGMiner(BaseMiner):
     async def get_data(self):
         data = MinerData(ip=str(self.ip), ideal_chips=self.nominal_chips * 3)
 
+        board_offset = -1
+        fan_offset = -1
+
         model = await self.get_model()
         hostname = await self.get_hostname()
         mac = await self.get_mac()
@@ -126,7 +129,9 @@ class CGMiner(BaseMiner):
 
         miner_data = None
         for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand("summary", "pools", "stats")
+            miner_data = await self.api.multicommand(
+                "summary", "pools", "stats", ignore_x19_error=True
+            )
             if miner_data:
                 break
 
@@ -141,25 +146,65 @@ class CGMiner(BaseMiner):
             hr = summary.get("SUMMARY")
             if hr:
                 if len(hr) > 0:
-                    hr = hr[0].get("GHS 1m")
+                    hr = hr[0].get("GHS av")
                     if hr:
                         data.hashrate = round(hr / 1000, 2)
 
+        if stats:
+            boards = stats.get("STATS")
+            if boards:
+                if len(boards) > 0:
+                    for board_num in range(1, 16, 5):
+                        for _b_num in range(5):
+                            b = boards[1].get(f"chain_acn{board_num + _b_num}")
+
+                            if b and not b == 0 and board_offset == -1:
+                                board_offset = board_num
+                    if board_offset == -1:
+                        board_offset = 1
+
+                    data.left_chips = boards[1].get(f"chain_acn{board_offset}")
+                    data.center_chips = boards[1].get(f"chain_acn{board_offset+1}")
+                    data.right_chips = boards[1].get(f"chain_acn{board_offset+2}")
+
+                    data.left_board_hashrate = round(
+                        float(boards[1].get(f"chain_rate{board_offset}")) / 1000, 2
+                    )
+                    data.center_board_hashrate = round(
+                        float(boards[1].get(f"chain_rate{board_offset+1}")) / 1000, 2
+                    )
+                    data.right_board_hashrate = round(
+                        float(boards[1].get(f"chain_rate{board_offset+2}")) / 1000, 2
+                    )
+
         if stats:
             temp = stats.get("STATS")
             if temp:
                 if len(temp) > 1:
-                    data.fan_1 = temp[1].get("fan1")
-                    data.fan_2 = temp[1].get("fan2")
-                    data.fan_3 = temp[1].get("fan3")
-                    data.fan_4 = temp[1].get("fan4")
+                    for fan_num in range(1, 8, 4):
+                        for _f_num in range(4):
+                            f = temp[1].get(f"fan{fan_num + _f_num}")
+                            if f and not f == 0 and fan_offset == -1:
+                                fan_offset = fan_num
+                    if fan_offset == -1:
+                        fan_offset = 1
+                    for fan in range(self.fan_count):
+                        setattr(
+                            data, f"fan_{fan + 1}", temp[1].get(f"fan{fan_offset+fan}")
+                        )
 
-                    board_map = {1: "left_board", 2: "center_board", 3: "right_board"}
-                    for item in range(1, 4):
-                        board_temp = temp[1].get(f"temp{item}")
-                        chip_temp = temp[1].get(f"temp2_{item}")
+                    board_map = {0: "left_board", 1: "center_board", 2: "right_board"}
+                    env_temp_list = []
+                    for item in range(3):
+                        board_temp = temp[1].get(f"temp{item + board_offset}")
+                        chip_temp = temp[1].get(f"temp2_{item + board_offset}")
                         setattr(data, f"{board_map[item]}_chip_temp", chip_temp)
                         setattr(data, f"{board_map[item]}_temp", board_temp)
+                        if f"temp_pcb{item}" in temp[1].keys():
+                            env_temp = temp[1][f"temp_pcb{item}"].split("-")[0]
+                            if not env_temp == 0:
+                                env_temp_list.append(int(env_temp))
+                    data.env_temp = sum(env_temp_list) / len(env_temp_list)
 
         if pools:
             pool_1 = None
@@ -173,16 +218,19 @@ class CGMiner(BaseMiner):
                 if not pool_1_user:
                     pool_1_user = pool.get("User")
                     pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
+                    if pool.get("Quota"):
+                        pool_2_quota = pool.get("Quota")
                 elif not pool_2_user:
                     pool_2_user = pool.get("User")
                     pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
+                    if pool.get("Quota"):
+                        pool_2_quota = pool.get("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.get("Quota"):
+                            pool_2_quota = pool.get("Quota")
             if pool_2_user and not pool_2_user == pool_1_user:
                 quota = f"{pool_1_quota}/{pool_2_quota}"
 

pyasic/miners/miner_factory.py

@@ -10,7 +10,9 @@ from pyasic.miners._backends.cgminer import CGMiner  # noqa - Ignore _module imp
 from pyasic.miners._backends.bmminer import BMMiner  # noqa - Ignore _module import
 from pyasic.miners._backends.bosminer import BOSMiner  # noqa - Ignore _module import
 from pyasic.miners._backends.btminer import BTMiner  # noqa - Ignore _module import
-from pyasic.miners._backends.bosminer_old import BOSMinerOld  # noqa - Ignore _module import
+from pyasic.miners._backends.bosminer_old import (
+    BOSMinerOld,
+)  # noqa - Ignore _module import
 
 from pyasic.miners.unknown import UnknownMiner
 
@@ -474,17 +476,20 @@ class MinerFactory(metaclass=Singleton):
 
                 # final try on a braiins OS bug with devdetails not returning
                 else:
-                    async with asyncssh.connect(
-                        str(ip),
-                        known_hosts=None,
-                        username="root",
-                        password="admin",
-                        server_host_key_algs=["ssh-rsa"],
-                    ) as conn:
-                        cfg = await conn.run("bosminer config --data")
-                    if cfg:
-                        cfg = json.loads(cfg.stdout)
-                        model = cfg.get("data").get("format").get("model")
+                    try:
+                        async with asyncssh.connect(
+                            str(ip),
+                            known_hosts=None,
+                            username="root",
+                            password="admin",
+                            server_host_key_algs=["ssh-rsa"],
+                        ) as conn:
+                            cfg = await conn.run("bosminer config --data")
+                        if cfg:
+                            cfg = json.loads(cfg.stdout)
+                            model = cfg.get("data").get("format").get("model")
+                    except asyncssh.misc.PermissionDenied:
+                        pass
 
         if model:
             # whatsminer have a V in their version string (M20SV41), remove everything after it

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.9.0"
+version = "0.10.0"
 description = "A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH."
 authors = ["UpstreamData <brett@upstreamdata.ca>"]