version: bump version number

pyasic/miners/_backends/bosminer.py

@@ -68,20 +68,23 @@ class BOSMiner(BaseMiner):
 
     async def send_graphql_query(self, query) -> Union[dict, None]:
         url = f"http://{self.ip}/graphql"
-        async with httpx.AsyncClient() as client:
-            _auth = await client.post(
-                url,
-                json={
-                    "query": 'mutation{auth{login(username:"'
-                    + self.uname
-                    + '", password:"'
-                    + self.pwd
-                    + '"){__typename}}}'
-                },
-            )
-            d = await client.post(url, json={"query": query})
-        if d.status_code == 200:
-            return d.json()
+        try:
+            async with httpx.AsyncClient() as client:
+                _auth = await client.post(
+                    url,
+                    json={
+                        "query": 'mutation{auth{login(username:"'
+                        + self.uname
+                        + '", password:"'
+                        + self.pwd
+                        + '"){__typename}}}'
+                    },
+                )
+                d = await client.post(url, json={"query": query})
+            if d.status_code == 200:
+                return d.json()
+        except httpx.ReadError:
+            return None
         return None
 
     async def fault_light_on(self) -> bool:
@@ -279,7 +282,7 @@ class BOSMiner(BaseMiner):
             try:
                 self.light = data["data"]["bos"]["faultLight"]
                 return self.light
-            except (TypeError, KeyError, ValueError):
+            except (TypeError, KeyError, ValueError, IndexError):
                 pass
 
         # get light via ssh if that fails (10x slower)
@@ -481,7 +484,7 @@ class BOSMiner(BaseMiner):
                     wattage_limit = tuner[0].get("PowerLimit")
                     if wattage_limit:
                         data.wattage_limit = wattage_limit
-                    if wattage:
+                    if wattage is not None:
                         data.wattage = wattage
 
                     chain_status = tuner[0].get("TunerChainStatus")
@@ -562,7 +565,7 @@ class BOSMiner(BaseMiner):
                     / 1000000,
                     2,
                 )
-        except (TypeError, KeyError, ValueError):
+        except (TypeError, KeyError, ValueError, IndexError):
             pass
 
         boards = None
@@ -578,10 +581,13 @@ class BOSMiner(BaseMiner):
                 board = data.hashboards[_id]
                 board.hashrate = round(hb["realHashrate"]["mhs1M"] / 1000000, 2)
                 temps = hb["temperatures"]
-                if len(temps) > 0:
-                    board.temp = round(hb["temperatures"][0]["degreesC"])
-                if len(temps) > 1:
-                    board.chip_temp = round(hb["temperatures"][1]["degreesC"])
+                try:
+                    if len(temps) > 0:
+                        board.temp = round(hb["temperatures"][0]["degreesC"])
+                    if len(temps) > 1:
+                        board.chip_temp = round(hb["temperatures"][1]["degreesC"])
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
                 details = hb.get("hwDetails")
                 if details:
                     if chips := details["chips"]:
@@ -602,18 +608,18 @@ class BOSMiner(BaseMiner):
                                 )
         try:
             data.wattage = query_data["bosminer"]["info"]["workSolver"]["power"]["approxConsumptionW"]
-        except (TypeError, KeyError, ValueError):
-            pass
+        except (TypeError, KeyError, ValueError, IndexError):
+            data.wattage = 0
         try:
             data.wattage_limit = query_data["bosminer"]["info"]["workSolver"]["power"]["limitW"]
-        except (TypeError, KeyError, ValueError):
+        except (TypeError, KeyError, ValueError, IndexError):
             pass
 
 
         for n in range(self.fan_count):
             try:
                 setattr(data, f"fan_{n + 1}", query_data["bosminer"]["info"]["fans"][n]["rpm"])
-            except (TypeError, KeyError, ValueError):
+            except (TypeError, KeyError, ValueError, IndexError):
                 pass
 
         groups = None
@@ -622,16 +628,40 @@ class BOSMiner(BaseMiner):
                 groups = query_data["bosminer"]["config"].get("groups")
         if groups:
             if len(groups) == 1:
-                data.pool_1_user = groups[0]["pools"][0]["user"]
-                data.pool_1_url = groups[0]["pools"][0]["url"]
-                data.pool_2_user = groups[0]["pools"][1]["user"]
-                data.pool_2_url = groups[0]["pools"][1]["url"]
+                try:
+                    data.pool_1_user = groups[0]["pools"][0]["user"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
+                try:
+                    data.pool_1_url = groups[0]["pools"][0]["url"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
+                try:
+                    data.pool_2_user = groups[0]["pools"][1]["user"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
+                try:
+                    data.pool_2_url = groups[0]["pools"][1]["url"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
                 data.quota = 0
             else:
-                data.pool_1_user = groups[0]["pools"][0]["user"]
-                data.pool_1_url = groups[0]["pools"][0]["url"]
-                data.pool_2_user = groups[1]["pools"][0]["user"]
-                data.pool_2_url = groups[1]["pools"][0]["url"]
+                try:
+                    data.pool_1_user = groups[0]["pools"][0]["user"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
+                try:
+                    data.pool_1_url = groups[0]["pools"][0]["url"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
+                try:
+                    data.pool_2_user = groups[1]["pools"][0]["user"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
+                try:
+                    data.pool_2_url = groups[1]["pools"][0]["url"]
+                except (TypeError, KeyError, ValueError, IndexError):
+                    pass
                 if groups[0]["strategy"].get("quota"):
                     data.quota = groups[0]["strategy"]["quota"] + "/" + groups[1]["strategy"]["quota"]
 

pyasic/miners/base.py

@@ -52,7 +52,7 @@ class BaseMiner(ABC):
         return object.__new__(cls)
 
     def __repr__(self):
-        return f"{'' if not self.api_type else self.api_type} {'' if not self.model else self.model}: {str(self.ip)}"
+        return f"{'' if not self.api_type else self.api_type}{'' if not self.model else ' ' + self.model}: {str(self.ip)}"
 
     def __lt__(self, other):
         return ipaddress.ip_address(self.ip) < ipaddress.ip_address(other.ip)

pyasic/miners/miner_factory.py

@@ -337,7 +337,6 @@ class MinerFactory(metaclass=Singleton):
                     break
             except asyncio.TimeoutError:
                 logging.warning(f"{ip}: Get Miner Timed Out")
-
         miner = self._select_miner_from_classes(ip, model, api, ver)
 
         # save the miner to the cache at its IP if its not unknown
@@ -412,7 +411,9 @@ class MinerFactory(metaclass=Singleton):
             # miner refused connection on API port, we wont be able to get data this way
             # try ssh
             try:
-                _model = await self.__get_model_from_ssh(ip)
+                _model = await self.__get_model_from_graphql(ip)
+                if not _model:
+                    _model = await self.__get_model_from_ssh(ip)
                 if _model:
                     model = _model
                     api = "BOSMiner+"
@@ -433,12 +434,6 @@ class MinerFactory(metaclass=Singleton):
 
         # if we have devdetails, we can get model data from there
         if devdetails:
-            if devdetails == {"Msg": "Disconnected"}:
-                model = await self.__get_model_from_graphql(ip)
-                if model:
-                    api = "BOSMiner+"
-                    return model, api, ver
-
             for _devdetails_key in ["Model", "Driver"]:
                 try:
                     model = devdetails["DEVDETAILS"][0][_devdetails_key].upper()
@@ -446,15 +441,42 @@ class MinerFactory(metaclass=Singleton):
                         break
                 except KeyError:
                     continue
+            try:
+                if devdetails[0]["STATUS"][0]["Msg"]:
+                    model = await self.__get_model_from_graphql(ip)
+                    if model:
+                        api = "BOSMiner+"
+            except (KeyError, TypeError, ValueError, IndexError):
+                pass
+
             if not model:
                 # braiins OS bug check just in case
                 if "s9" in devdetails["STATUS"][0]["Description"]:
                     model = "ANTMINER S9"
                 if "s17" in version["STATUS"][0]["Description"]:
                     model = "ANTMINER S17"
+            if not api:
+                if "boser" in version["STATUS"][0]["Description"]:
+                    api = "BOSMiner+"
+        else:
+            try:
+                _model = await self.__get_model_from_graphql(ip)
+                if _model:
+                    model = _model
+                    api = "BOSMiner+"
+            except (KeyError, TypeError, ValueError, IndexError):
+                pass
 
         # if we have version we can get API type from here
         if version:
+            try:
+                if version[0]["STATUS"][0]["Msg"]:
+                    model = await self.__get_model_from_graphql(ip)
+                    if model:
+                        api = "BOSMiner+"
+                        return model, api, ver
+            except (KeyError, TypeError, ValueError, IndexError):
+                pass
             if "VERSION" in version:
                 api_types = ["BMMiner", "CGMiner", "BTMiner"]
                 # check basic API types, BOSMiner needs a special check
@@ -470,6 +492,8 @@ class MinerFactory(metaclass=Singleton):
                             api = "BOSMiner+"
                     if "BOSminer+" in version["VERSION"][0]:
                         api = "BOSMiner+"
+                if any("BOSer" in string for string in version["VERSION"][0]):
+                    api = "BOSMiner+"
 
                 # check for avalonminers
                 for _version_key in ["PROD", "MODEL"]:
@@ -533,7 +557,6 @@ class MinerFactory(metaclass=Singleton):
             # don't need "Bitmain", just "ANTMINER XX" as model
             if "BITMAIN " in model:
                 model = model.replace("BITMAIN ", "")
-
         return model, api, ver
 
     async def __get_devdetails_and_version(
@@ -548,7 +571,7 @@ class MinerFactory(metaclass=Singleton):
             if not validation[0]:
                 try:
                     if data["version"][0]["STATUS"][0]["Msg"] == "Disconnected":
-                        return {"Msg": "Disconnected"}, None
+                        return data["devdetails"], data["version"]
                 except KeyError:
                     pass
                 raise APIError(validation[1])
@@ -605,7 +628,7 @@ class MinerFactory(metaclass=Singleton):
         async with httpx.AsyncClient() as client:
             d = await client.post(url, json={"query": "{bosminer {info{modelName}}}"})
         if d.status_code == 200:
-            model = d.json()["data"]["bosminer"]["info"]["modelName"].upper()
+            model = (d.json()["data"]["bosminer"]["info"]["modelName"]).upper()
         return model
 
     @staticmethod

pyproject.toml

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