version: bump version number.

pyasic/API/__init__.py

@@ -162,7 +162,7 @@ If you are sure you want to use this command please use API.send_command("{comma
             reader, writer = await asyncio.open_connection(str(self.ip), self.port)
         # handle OSError 121
         except OSError as e:
-            if getattr(e, "winerror") == "121":
+            if e.errno == 121:
                 logging.warning(
                     f"{self} - ([Hidden] Send Bytes) - Semaphore timeout expired."
                 )

pyasic/config/__init__.py

@@ -245,7 +245,9 @@ class MinerConfig:
         fan_speed: Manual fan speed to run the fan at (only if temp_mode == "manual").
         asicboost: Whether or not to enable asicboost.
         autotuning_enabled: Whether or not to enable autotuning.
+        autotuning_mode: Autotuning mode, either "wattage" or "hashrate".
         autotuning_wattage: The wattage to use when autotuning.
+        autotuning_hashrate: The hashrate to use when autotuning.
         dps_enabled: Whether or not to enable dynamic power scaling.
         dps_power_step: The amount of power to reduce autotuning by when the miner reaches dangerous temp.
         dps_min_power: The minimum power to reduce autotuning to.
@@ -266,7 +268,9 @@ class MinerConfig:
     asicboost: bool = None
 
     autotuning_enabled: bool = True
-    autotuning_wattage: int = 900
+    autotuning_mode: Literal["power", "hashrate"] = None
+    autotuning_wattage: int = None
+    autotuning_hashrate: int = None
 
     dps_enabled: bool = None
     dps_power_step: int = None
@@ -349,14 +353,20 @@ class MinerConfig:
                         self.autotuning_enabled = data[key][_key]
                     elif _key == "psu_power_limit":
                         self.autotuning_wattage = data[key][_key]
+                    elif _key == "power_target":
+                        self.autotuning_wattage = data[key][_key]
+                    elif _key == "hashrate_target":
+                        self.autotuning_hashrate = data[key][_key]
+                    elif _key == "mode":
+                        self.autotuning_mode = data[key][_key].replace("_target", "")
 
-            if key == "power_scaling":
+            if key in ["power_scaling", "performance_scaling"]:
                 for _key in data[key].keys():
                     if _key == "enabled":
                         self.dps_enabled = data[key][_key]
                     elif _key == "power_step":
                         self.dps_power_step = data[key][_key]
-                    elif _key == "min_psu_power_limit":
+                    elif _key in ["min_psu_power_limit", "min_power_target"]:
                         self.dps_min_power = data[key][_key]
                     elif _key == "shutdown_enabled":
                         self.dps_shutdown_enabled = data[key][_key]
@@ -391,8 +401,8 @@ class MinerConfig:
         pool_groups = []
         for group in data["pool_groups"]:
             pool_groups.append(_PoolGroup().from_dict(group))
-        for key in data.keys():
+        for key in data:
-            if getattr(self, key) and not key == "pool_groups":
+            if hasattr(self, key) and not key == "pool_groups":
                 setattr(self, key, data[key])
         self.pool_groups = pool_groups
         return self
@@ -481,8 +491,8 @@ class MinerConfig:
         cfg = {
             "format": {
                 "version": "1.2+",
-                "model": f"Antminer {model}",
+                "model": f"Antminer {model.replace('j', 'J')}",
-                "generator": "Upstream Config Utility",
+                "generator": "pyasic",
                 "timestamp": int(time.time()),
             },
             "group": [
@@ -499,9 +509,19 @@ class MinerConfig:
         if self.autotuning_enabled or self.autotuning_wattage:
             cfg["autotuning"] = {}
             if self.autotuning_enabled:
-                cfg["autotuning"]["enabled"] = self.autotuning_enabled
+                cfg["autotuning"]["enabled"] = True
-            if self.autotuning_wattage:
+            else:
-                cfg["autotuning"]["psu_power_limit"] = self.autotuning_wattage
+                cfg["autotuning"]["enabled"] = False
+            if self.autotuning_mode:
+                cfg["format"]["version"] = "2.0"
+                cfg["autotuning"]["mode"] = self.autotuning_mode + "_target"
+                if self.autotuning_wattage:
+                    cfg["autotuning"]["power_target"] = self.autotuning_wattage
+                elif self.autotuning_hashrate:
+                    cfg["autotuning"]["hashrate_target"] = self.autotuning_hashrate
+            else:
+                if self.autotuning_wattage:
+                    cfg["autotuning"]["psu_power_limit"] = self.autotuning_wattage
 
         if self.asicboost:
             cfg["hash_chain_global"] = {}
@@ -525,7 +545,10 @@ class MinerConfig:
             if self.dps_power_step:
                 cfg["power_scaling"]["power_step"] = self.dps_power_step
             if self.dps_min_power:
-                cfg["power_scaling"]["min_psu_power_limit"] = self.dps_min_power
+                if cfg["format"]["version"] == "2.0":
+                    cfg["power_scaling"]["min_power_target"] = self.dps_min_power
+                else:
+                    cfg["power_scaling"]["min_psu_power_limit"] = self.dps_min_power
             if self.dps_shutdown_enabled:
                 cfg["power_scaling"]["shutdown_enabled"] = self.dps_shutdown_enabled
             if self.dps_shutdown_duration:

pyasic/data/__init__.py

@@ -403,6 +403,8 @@ class MinerData:
 
     @property
     def percent_ideal(self):  # noqa - Skip PyCharm inspection
+        if self.total_chips == 0 or self.ideal_chips == 0:
+            return 0
         return round((self.total_chips / self.ideal_chips) * 100)
 
     @percent_ideal.setter

pyasic/miners/_backends/bosminer.py

@@ -198,11 +198,8 @@ class BOSMiner(BaseMiner):
                 return self.config
         if conn:
             async with conn:
-                logging.debug(f"{self}: Opening SFTP connection.")
+                # good ol' BBB compatibility :/
-                async with conn.start_sftp_client() as sftp:
+                toml_data = toml.loads((await conn.run("cat /etc/bosminer.toml")).stdout)
-                    logging.debug(f"{self}: Reading config file.")
-                    async with sftp.open("/etc/bosminer.toml") as file:
-                        toml_data = toml.loads(await file.read())
             logging.debug(f"{self}: Converting config file.")
             cfg = MinerConfig().from_raw(toml_data)
             self.config = cfg
@@ -219,14 +216,28 @@ class BOSMiner(BaseMiner):
         except (asyncssh.Error, OSError):
             return None
         async with conn:
-            await conn.run("/etc/init.d/bosminer stop")
+            # BBB check because bitmain suxx
-            logging.debug(f"{self}: Opening SFTP connection.")
+            bbb_check = await conn.run("if [ ! -f /etc/init.d/bosminer ]; then echo '1'; else echo '0'; fi;")
-            async with conn.start_sftp_client() as sftp:
+
-                logging.debug(f"{self}: Opening config file.")
+            bbb = bbb_check.stdout.strip() == "1"
-                async with sftp.open("/etc/bosminer.toml", "w+") as file:
+
-                    await file.write(toml_conf)
+            if not bbb:
-            logging.debug(f"{self}: Restarting BOSMiner")
+                await conn.run("/etc/init.d/bosminer stop")
-            await conn.run("/etc/init.d/bosminer start")
+                logging.debug(f"{self}: Opening SFTP connection.")
+                async with conn.start_sftp_client() as sftp:
+                    logging.debug(f"{self}: Opening config file.")
+                    async with sftp.open("/etc/bosminer.toml", "w+") as file:
+                        await file.write(toml_conf)
+                logging.debug(f"{self}: Restarting BOSMiner")
+                await conn.run("/etc/init.d/bosminer start")
+
+            # I really hate BBB, please get rid of it if you have it
+            else:
+                await conn.run("/etc/init.d/S99bosminer stop")
+                logging.debug(f"{self}: BBB sending config")
+                await conn.run("echo '" + toml_conf + "' > /etc/bosminer.toml")
+                logging.debug(f"{self}: BBB restarting bosminer.")
+                await conn.run("/etc/init.d/S99bosminer start")
 
     async def set_power_limit(self, wattage: int) -> bool:
         try:

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

@@ -174,10 +174,7 @@ class M30SPlusPlusVH50(WhatsMiner):  # noqa - ignore ABC method implementation
         super().__init__()
         self.ip = ip
         self.model = "M30S++ VH50"
-        self.nominal_chips = 0
+        self.nominal_chips = 74
-        warnings.warn(
-            "Unknown chip count for miner type M30S++ VH50, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
-        )
         self.fan_count = 2
 
 
@@ -195,10 +192,7 @@ class M30SPlusPlusVH70(WhatsMiner):  # noqa - ignore ABC method implementation
         super().__init__()
         self.ip = ip
         self.model = "M30S++ VH70"
-        self.nominal_chips = 0
+        self.nominal_chips = 70
-        warnings.warn(
-            "Unknown chip count for miner type M30S++ VH70, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
-        )
         self.fan_count = 2
 
 

pyasic/miners/base.py

@@ -162,7 +162,7 @@ class BaseMiner(ABC):
 
     @abstractmethod
     async def resume_mining(self) -> bool:
-        """Stop the mining process of the miner.
+        """Resume the mining process of the miner.
 
         Returns:
             A boolean value of the success of resuming the mining process.

pyasic/network/__init__.py

@@ -108,10 +108,6 @@ class MinerNetwork:
         # clear cached miners
         MinerFactory().clear_cached_miners()
 
-        # create a list of tasks and miner IPs
-        scan_tasks = []
-        miners = []
-
         limit = asyncio.Semaphore(PyasicSettings().network_scan_threads)
         miners = await asyncio.gather(
             *[self.ping_and_get_miner(host, limit) for host in local_network.hosts()]
@@ -140,8 +136,6 @@ class MinerNetwork:
         local_network = self.get_network()
 
         # create a list of scan tasks
-        scan_tasks = []
-
         limit = asyncio.Semaphore(PyasicSettings().network_scan_threads)
         miners = asyncio.as_completed(
             [
@@ -213,14 +207,13 @@ async def ping_miner(
         except asyncio.exceptions.TimeoutError:
             # ping failed if we time out
             continue
-        except ConnectionRefusedError:
+        except (ConnectionRefusedError, OSError):
             # handle for other connection errors
             logging.debug(f"{str(ip)}: Connection Refused.")
             raise ConnectionRefusedError
-        # ping failed, likely with an exception
         except Exception as e:
-            logging.warning(f"{str(ip)}: {e}")
+            logging.warning(f"{str(ip)}: Ping And Get Miner Exception: {e}")
-        continue
+            raise ConnectionRefusedError
     return
 
 
@@ -228,8 +221,8 @@ async def ping_and_get_miner(
     ip: ipaddress.ip_address, port=4028
 ) -> Union[None, AnyMiner]:
     for i in range(PyasicSettings().network_ping_retries):
-        connection_fut = asyncio.open_connection(str(ip), port)
         try:
+            connection_fut = asyncio.open_connection(str(ip), port)
             # get the read and write streams from the connection
             reader, writer = await asyncio.wait_for(
                 connection_fut, timeout=PyasicSettings().network_ping_timeout
@@ -243,13 +236,11 @@ async def ping_and_get_miner(
         except asyncio.exceptions.TimeoutError:
             # ping failed if we time out
             continue
-        except ConnectionRefusedError as e:
+        except (ConnectionRefusedError, OSError):
             # handle for other connection errors
             logging.debug(f"{str(ip)}: Connection Refused.")
-            raise e
+            raise ConnectionRefusedError
-        # ping failed, likely with an exception
         except Exception as e:
             logging.warning(f"{str(ip)}: Ping And Get Miner Exception: {e}")
-            raise e
+            raise ConnectionRefusedError
-        continue
     return

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.28.6"
+version = "0.29.7"
 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>"]
 repository = "https://github.com/UpstreamData/pyasic"

tests/__init__.py

@@ -16,7 +16,6 @@
 
 import unittest
 
-from tests.config_tests import ConfigTest
 from tests.miners_tests import MinerFactoryTest, MinersTest
 from tests.network_tests import NetworkTest
 

tests/config_tests/__init__.py

@@ -1,113 +0,0 @@
-# ------------------------------------------------------------------------------
-#  Copyright 2022 Upstream Data Inc                                            -
-#                                                                              -
-#  Licensed under the Apache License, Version 2.0 (the "License");             -
-#  you may not use this file except in compliance with the License.            -
-#  You may obtain a copy of the License at                                     -
-#                                                                              -
-#      http://www.apache.org/licenses/LICENSE-2.0                              -
-#                                                                              -
-#  Unless required by applicable law or agreed to in writing, software         -
-#  distributed under the License is distributed on an "AS IS" BASIS,           -
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
-#  See the License for the specific language governing permissions and         -
-#  limitations under the License.                                              -
-# ------------------------------------------------------------------------------
-import unittest
-
-from pyasic.config import MinerConfig, _Pool, _PoolGroup  # noqa
-from tests.test_data import (
-    bosminer_api_pools,
-    bosminer_config_pools,
-    x19_api_pools,
-    x19_web_pools,
-)
-
-
-class ConfigTest(unittest.TestCase):
-    def setUp(self) -> None:
-        self.test_config = MinerConfig(
-            pool_groups=[
-                _PoolGroup(
-                    quota=1,
-                    group_name="TEST",
-                    pools=[
-                        _Pool(
-                            url="stratum+tcp://pyasic.testpool_1.pool:3333",
-                            username="pyasic.test",
-                            password="123",
-                        ),
-                        _Pool(
-                            url="stratum+tcp://pyasic.testpool_2.pool:3333",
-                            username="pyasic.test",
-                            password="123",
-                        ),
-                    ],
-                )
-            ],
-            temp_mode="auto",
-            temp_target=70.0,
-            temp_hot=80.0,
-            temp_dangerous=100.0,
-            fan_speed=None,
-            autotuning_enabled=True,
-            autotuning_wattage=900,
-        )
-
-    def test_config_from_raw(self):
-        bos_config = MinerConfig().from_raw(bosminer_config_pools)
-        bos_config.pool_groups[0].group_name = "TEST"
-
-        with self.subTest(
-            msg="Testing BOSMiner config file config.", bos_config=bos_config
-        ):
-            self.assertEqual(bos_config, self.test_config)
-
-        x19_cfg = MinerConfig().from_raw(x19_web_pools)
-        x19_cfg.pool_groups[0].group_name = "TEST"
-
-        with self.subTest(msg="Testing X19 API config.", x19_cfg=x19_cfg):
-            self.assertEqual(x19_cfg, self.test_config)
-
-    def test_config_from_api(self):
-        bos_cfg = MinerConfig().from_api(bosminer_api_pools["POOLS"])
-        bos_cfg.pool_groups[0].group_name = "TEST"
-
-        with self.subTest(msg="Testing BOSMiner API config.", bos_cfg=bos_cfg):
-            self.assertEqual(bos_cfg, self.test_config)
-
-        x19_cfg = MinerConfig().from_api(x19_api_pools["POOLS"])
-        x19_cfg.pool_groups[0].group_name = "TEST"
-
-        with self.subTest(msg="Testing X19 API config.", x19_cfg=x19_cfg):
-            self.assertEqual(x19_cfg, self.test_config)
-
-    def test_config_as_types(self):
-        cfg = MinerConfig().from_api(bosminer_api_pools["POOLS"])
-        cfg.pool_groups[0].group_name = "TEST"
-
-        commands = [
-            func
-            for func in
-            # each function in self
-            dir(cfg)
-            if callable(getattr(cfg, func)) and
-            # no __ methods
-            not func.startswith("__")
-        ]
-
-        for command in [cmd for cmd in commands if cmd.startswith("as_")]:
-            with self.subTest():
-                output = getattr(cfg, command)()
-                self.assertEqual(output, getattr(self.test_config, command)())
-                if f"from_{command.split('as_')[1]}" in commands:
-                    self.assertEqual(
-                        getattr(MinerConfig(), f"from_{command.split('as_')[1]}")(
-                            output
-                        ),
-                        self.test_config,
-                    )
-
-
-if __name__ == "__main__":
-    unittest.main()