bump version number

pyasic/API/__init__.py

@@ -42,7 +42,11 @@ class BaseMinerAPI:
         self.ip = ipaddress.ip_address(ip)
 
     def get_commands(self) -> list:
-        """Get a list of command accessible to a specific type of API on the miner."""
+        """Get a list of command accessible to a specific type of API on the miner.
+
+        Returns:
+            A list of all API commands that the miner supports.
+        """
         return [
             func
             for func in
@@ -60,42 +64,56 @@ class BaseMinerAPI:
             ]
         ]
 
+    def _check_commands(self, *commands):
+        allowed_commands = self.get_commands()
+        return_commands = []
+        for command in [*commands]:
+            if command in allowed_commands:
+                return_commands.append(command)
+            else:
+                warnings.warn(
+                    f"""Removing incorrect command: {command}
+If you are sure you want to use this command please use API.send_command("{command}", ignore_errors=True) instead.""",
+                    APIWarning,
+                )
+        return return_commands
+
     async def multicommand(
         self, *commands: str, ignore_x19_error: bool = False
     ) -> dict:
-        """Creates and sends multiple commands as one command to the miner."""
+        """Creates and sends multiple commands as one command to the miner.
+
+        Parameters:
+            *commands: The commands to send as a multicommand to the miner.
+            ignore_x19_error: Whether or not to ignore errors raised by x19 miners when using the "+" delimited style.
+        """
         logging.debug(f"{self.ip}: Sending multicommand: {[*commands]}")
-        # split the commands into a proper list
-        user_commands = [*commands]
-        allowed_commands = self.get_commands()
-        # make sure we can actually run the command, otherwise it will fail
-        commands = [command for command in user_commands if command in allowed_commands]
-        for item in list(set(user_commands) - set(commands)):
-            warnings.warn(
-                f"""Removing incorrect command: {item}
-If you are sure you want to use this command please use API.send_command("{item}", ignore_errors=True) instead.""",
-                APIWarning,
-            )
+        # make sure we can actually run each command, otherwise they will fail
+        commands = self._check_commands(*commands)
         # standard multicommand format is "command1+command2"
-        # doesnt work for S19 which is dealt with in the send command function
+        # doesnt work for S19 which uses the backup _x19_multicommand
         command = "+".join(commands)
-        data = None
         try:
             data = await self.send_command(command, x19_command=ignore_x19_error)
         except APIError:
-            try:
-                data = {}
-                # S19 handler, try again
-                for cmd in command.split("+"):
-                    data[cmd] = []
-                    data[cmd].append(await self.send_command(cmd))
-            except APIError as e:
-                raise APIError(e)
-            except Exception as e:
-                logging.warning(f"{self.ip}: API Multicommand Error: {e}")
-        if data:
-            logging.debug(f"{self.ip}: Received multicommand data.")
-            return data
+            logging.debug(f"{self.ip}: Handling X19 multicommand.")
+            data = await self._x19_multicommand(command.split("+"))
+        logging.debug(f"{self.ip}: Received multicommand data.")
+        return data
+
+    async def _x19_multicommand(self, *commands):
+        data = None
+        try:
+            data = {}
+            # send all commands individually
+            for cmd in commands:
+                data[cmd] = []
+                data[cmd].append(await self.send_command(cmd, x19_command=True))
+        except APIError as e:
+            raise APIError(e)
+        except Exception as e:
+            logging.warning(f"{self.ip}: API Multicommand Error: {e.__name__} - {e}")
+        return data
 
     async def send_command(
         self,
@@ -104,7 +122,17 @@ If you are sure you want to use this command please use API.send_command("{item}
         ignore_errors: bool = False,
         x19_command: bool = False,
     ) -> dict:
-        """Send an API command to the miner and return the result."""
+        """Send an API command to the miner and return the result.
+
+        Parameters:
+            command: The command to sent to the miner.
+            parameters: Any additional parameters to be sent with the command.
+            ignore_errors: Whether or not to raise APIError when the command returns an error.
+            x19_command: Whether this is a command for an x19 that may be an issue (such as a "+" delimited multicommand)
+
+        Returns:
+            The return data from the API command parsed from JSON into a dict.
+        """
         try:
             # get reader and writer streams
             reader, writer = await asyncio.open_connection(str(self.ip), self.port)
@@ -116,7 +144,7 @@ If you are sure you want to use this command please use API.send_command("{item}
 
         # create the command
         cmd = {"command": command}
-        if parameters is not None:
+        if parameters:
             cmd["parameter"] = parameters
 
         # send the command
@@ -134,9 +162,9 @@ If you are sure you want to use this command please use API.send_command("{item}
                     break
                 data += d
         except Exception as e:
-            logging.warning(f"{self.ip}: API Command Error: {e}")
+            logging.warning(f"{self.ip}: API Command Error: {e.__name__} - {e}")
 
-        data = self.load_api_data(data)
+        data = self._load_api_data(data)
 
         # close the connection
         writer.close()
@@ -145,7 +173,7 @@ If you are sure you want to use this command please use API.send_command("{item}
         # check for if the user wants to allow errors to return
         if not ignore_errors:
             # validate the command succeeded
-            validation = self.validate_command_output(data)
+            validation = self._validate_command_output(data)
             if not validation[0]:
                 if not x19_command:
                     logging.warning(f"{self.ip}: API Command Error: {validation[1]}")
@@ -154,8 +182,7 @@ If you are sure you want to use this command please use API.send_command("{item}
         return data
 
     @staticmethod
-    def validate_command_output(data: dict) -> tuple:
-        """Check if the returned command output is correctly formatted."""
+    def _validate_command_output(data: dict) -> tuple:
         # check if the data returned is correct or an error
         # if status isn't a key, it is a multicommand
         if "STATUS" not in data.keys():
@@ -182,8 +209,7 @@ If you are sure you want to use this command please use API.send_command("{item}
         return True, None
 
     @staticmethod
-    def load_api_data(data: bytes) -> dict:
-        """Convert API data from JSON to dict"""
+    def _load_api_data(data: bytes) -> dict:
         str_data = None
         try:
             # some json from the API returns with a null byte (\x00) on the end

pyasic/API/btminer.py

@@ -209,7 +209,7 @@ class BTMinerAPI(BaseMinerAPI):
         except Exception as e:
             logging.info(f"{str(self.ip)}: {e}")
 
-        data = self.load_api_data(data)
+        data = self._load_api_data(data)
 
         # close the connection
         writer.close()
@@ -225,7 +225,7 @@ class BTMinerAPI(BaseMinerAPI):
 
         if not ignore_errors:
             # if it fails to validate, it is likely an error
-            validation = self.validate_command_output(data)
+            validation = self._validate_command_output(data)
             if not validation[0]:
                 raise APIError(validation[1])
 

pyasic/miners/__init__.py

@@ -54,13 +54,11 @@ class BaseMiner:
                 )
                 return conn
             except Exception as e:
-                # logging.warning(f"{self} raised an exception: {e}")
                 raise e
         except OSError as e:
             logging.warning(f"Connection refused: {self}")
             raise e
         except Exception as e:
-            # logging.warning(f"{self} raised an exception: {e}")
             raise e
 
     async def fault_light_on(self) -> bool:

pyasic/miners/miner_factory.py

@@ -1,6 +1,7 @@
 from typing import TypeVar, Tuple, List, Union
 from collections.abc import AsyncIterable
 from pyasic.miners import BaseMiner
+import httpx
 
 from pyasic.miners.antminer import *
 from pyasic.miners.avalonminer import *
@@ -418,7 +419,19 @@ class MinerFactory(metaclass=Singleton):
                     return model, api, None
 
             except asyncssh.misc.PermissionDenied:
-                return None, None, None
+                try:
+                    url = f"http://{self.ip}/cgi-bin/get_system_info.cgi"
+                    auth = httpx.DigestAuth("root", "root")
+                    async with httpx.AsyncClient() as client:
+                        data = await client.get(url, auth=auth)
+                    if data.status_code == 200:
+                        data = data.json()
+                    if "minertype" in data.keys():
+                        model = data["minertype"]
+                    if "bmminer" in "\t".join(data.keys()):
+                        api = "BMMiner"
+                except:
+                    return None, None, None
 
         # if we have devdetails, we can get model data from there
         if devdetails:

pyasic/misc/bos.py

@@ -1,70 +0,0 @@
-import asyncio
-from pyasic.network import MinerNetwork
-from pyasic.miners._backends.bosminer import BOSMiner  # noqa - Ignore access to _module
-
-
-async def get_bos_bad_tuners(ip: str = "192.168.1.0", mask: int = 24):
-    # create a miner network
-    miner_network = MinerNetwork(ip, mask=mask)
-
-    # scan for miners
-    miners = await miner_network.scan_network_for_miners()
-
-    # create an empty list of tasks
-    tuner_tasks = []
-
-    # loop checks if the miner is a BOSMiner
-    for miner in miners:
-        # can only do this if its a subclass of BOSMiner
-        if BOSMiner in type(miner).__bases__:
-            tuner_tasks.append(_get_tuner_status(miner))
-
-    # run all the tuner status commands
-    tuner_status = await asyncio.gather(*tuner_tasks)
-
-    # create a list of all miners with bad board tuner status
-    bad_tuner_miners = []
-    for item in tuner_status:
-        # loop through and get each miners' bad board count
-        bad_boards = []
-        for board in item["tuner_status"]:
-            # if its not stable or still testing, its bad
-            if board["status"] not in [
-                "Stable",
-                "Testing performance profile",
-                "Tuning individual chips",
-            ]:
-                # remove the part about the board refusing to start
-                bad_boards.append(
-                    {
-                        "board": board["board"],
-                        "error": board["status"].replace(
-                            "Hashchain refused to start: ", ""
-                        ),
-                    }
-                )
-
-        # if this miner has bad boards, add it to the list of bad board miners
-        if len(bad_boards) > 0:
-            bad_tuner_miners.append({"ip": item["ip"], "boards": bad_boards})
-
-    # return the list of bad board miners
-    return bad_tuner_miners
-
-
-async def _get_tuner_status(miner):
-    # run the tunerstatus command, since the miner will always be BOSMiner
-    tuner_status = await miner.api.tunerstatus()
-
-    # create a list to add the tuner data to
-    tuner_data = []
-
-    # if we have data, loop through to get the hashchain status
-    if tuner_status:
-        for board in tuner_status["TUNERSTATUS"][0]["TunerChainStatus"]:
-            tuner_data.append(
-                {"board": board["HashchainIndex"], "status": board["Status"]}
-            )
-
-    # return the data along with the IP or later tracking
-    return {"ip": str(miner.ip), "tuner_status": tuner_data}

pyasic/network/__init__.py

@@ -1,7 +1,7 @@
 import ipaddress
 import asyncio
 import logging
-from typing import Union
+from typing import Union, List, AsyncIterator
 
 from pyasic.network.net_range import MinerNetworkRange
 from pyasic.miners.miner_factory import MinerFactory, AnyMiner
@@ -40,7 +40,11 @@ class MinerNetwork:
         return str(self.network)
 
     def get_network(self) -> ipaddress.ip_network:
-        """Get the network using the information passed to the MinerNetwork or from cache."""
+        """Get the network using the information passed to the MinerNetwork or from cache.
+
+        Returns:
+            The proper network to be able to scan.
+        """
         # if we have a network cached already, use that
         if self.network:
             return self.network
@@ -68,13 +72,19 @@ class MinerNetwork:
             self.network = ipaddress.ip_network(
                 f"{default_gateway}/{subnet_mask}", strict=False
             )
+
+        logging.debug(f"Setting MinerNetwork: {self.network}")
         return self.network
 
-    async def scan_network_for_miners(self) -> None or list:
-        """Scan the network for miners, and return found miners as a list."""
+    async def scan_network_for_miners(self) -> List[AnyMiner]:
+        """Scan the network for miners, and return found miners as a list.
+
+        Returns:
+            A list of found miners.
+        """
         # get the network
         local_network = self.get_network()
-        print(f"Scanning {local_network} for miners...")
+        logging.debug(f"Scanning {local_network} for miners")
 
         # clear cached miners
         MinerFactory().clear_cached_miners()
@@ -103,16 +113,17 @@ class MinerNetwork:
 
         # remove all None from the miner list
         miners = list(filter(None, miners))
-        print(f"Found {len(miners)} connected miners...")
+        logging.debug(f"Found {len(miners)} connected miners")
 
         # return the miner objects
         return miners
 
-    async def scan_network_generator(self):
+    async def scan_network_generator(self) -> AsyncIterator[AnyMiner]:
         """
         Scan the network for miners using an async generator.
 
-        Returns an asynchronous generator containing found miners.
+        Returns:
+             An asynchronous generator containing found miners.
         """
         # get the current event loop
         loop = asyncio.get_event_loop()
@@ -145,7 +156,7 @@ class MinerNetwork:
             yield await miner
 
     @staticmethod
-    async def ping_miner(ip: ipaddress.ip_address) -> None or ipaddress.ip_address:
+    async def ping_miner(ip: ipaddress.ip_address) -> Union[None, ipaddress.ip_address]:
         tasks = [ping_miner(ip, port=port) for port in [4028, 4029, 8889]]
         for miner in asyncio.as_completed(tasks):
             miner = await miner
@@ -155,7 +166,7 @@ class MinerNetwork:
     @staticmethod
     async def ping_and_get_miner(
         ip: ipaddress.ip_address,
-    ) -> None or AnyMiner:
+    ) -> Union[None, AnyMiner]:
         tasks = [ping_and_get_miner(ip, port=port) for port in [4028, 4029, 8889]]
         for miner in asyncio.as_completed(tasks):
             miner = await miner
@@ -165,7 +176,7 @@ class MinerNetwork:
 
 async def ping_miner(
     ip: ipaddress.ip_address, port=4028
-) -> None or ipaddress.ip_address:
+) -> Union[None, ipaddress.ip_address]:
     for i in range(PyasicSettings().network_ping_retries):
         connection_fut = asyncio.open_connection(str(ip), port)
         try:
@@ -192,7 +203,9 @@ async def ping_miner(
     return
 
 
-async def ping_and_get_miner(ip: ipaddress.ip_address, port=4028) -> None or AnyMiner:
+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:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.12.3"
+version = "0.12.4"
 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"