refactor: swap (KeyError, IndexError) for LookupError.

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

@@ -69,14 +69,14 @@ class HiveonT9(Hiveon, T9):
                         hashboards[board].chip_temp = api_stats["STATS"][1][
                             f"temp2_{chipset}"
                         ]
-                    except (KeyError, IndexError):
+                    except LookupError:
                         pass
                     else:
                         hashboards[board].missing = False
                 try:
                     hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"]
                     chips += api_stats["STATS"][1][f"chain_acn{chipset}"]
-                except (KeyError, IndexError):
+                except LookupError:
                     pass
             hashboards[board].hashrate = round(hashrate / 1000, 2)
             hashboards[board].chips = chips
@@ -94,7 +94,7 @@ class HiveonT9(Hiveon, T9):
             boards = api_stats.get("STATS")
             try:
                 wattage_raw = boards[1]["chain_power"]
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
             else:
                 # parse wattage position out of raw data
@@ -119,7 +119,7 @@ class HiveonT9(Hiveon, T9):
                         env_temp = api_stats["STATS"][1][f"temp3_{chipset}"]
                         if not env_temp == 0:
                             env_temp_list.append(int(env_temp))
-                    except (KeyError, IndexError):
+                    except LookupError:
                         pass
 
             if not env_temp_list == []:

pyasic/miners/backends/braiins_os.py

@@ -478,7 +478,7 @@ class BOSMiner(BaseMiner):
         if api_version:
             try:
                 api_ver = api_version["VERSION"][0]["API"]
-            except (KeyError, IndexError):
+            except LookupError:
                 api_ver = None
             self.api_ver = api_ver
             self.api.api_ver = self.api_ver
@@ -580,7 +580,7 @@ class BOSMiner(BaseMiner):
         if api_summary:
             try:
                 return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
-            except (KeyError, IndexError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
     async def _get_hashboards(
@@ -642,7 +642,7 @@ class BOSMiner(BaseMiner):
                             board.temp = round(hb["temperatures"][0]["degreesC"])
                         if len(temps) > 1:
                             board.chip_temp = round(hb["temperatures"][1]["degreesC"])
-                    except (TypeError, KeyError, ValueError, IndexError):
+                    except (LookupError, TypeError, ValueError):
                         pass
                     details = hb.get("hwDetails")
                     if details:
@@ -666,15 +666,15 @@ class BOSMiner(BaseMiner):
                 d = {}
             try:
                 api_temps = d["temps"][0]
-            except (KeyError, IndexError):
+            except LookupError:
                 api_temps = None
             try:
                 api_devdetails = d["devdetails"][0]
-            except (KeyError, IndexError):
+            except LookupError:
                 api_devdetails = None
             try:
                 api_devs = d["devs"][0]
-            except (KeyError, IndexError):
+            except LookupError:
                 api_devs = None
         if api_temps:
             try:
@@ -686,7 +686,7 @@ class BOSMiner(BaseMiner):
                     board_temp = round(board["Board"])
                     hashboards[_id].chip_temp = chip_temp
                     hashboards[_id].temp = board_temp
-            except (IndexError, KeyError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
         if api_devdetails:
@@ -698,7 +698,7 @@ class BOSMiner(BaseMiner):
                     chips = board["Chips"]
                     hashboards[_id].chips = chips
                     hashboards[_id].missing = False
-            except (IndexError, KeyError):
+            except LookupError:
                 pass
 
         if api_devs:
@@ -709,7 +709,7 @@ class BOSMiner(BaseMiner):
                     _id = board["ID"] - offset
                     hashrate = round(float(board["MHS 1m"] / 1000000), 2)
                     hashboards[_id].hashrate = hashrate
-            except (IndexError, KeyError):
+            except LookupError:
                 pass
 
         return hashboards
@@ -750,7 +750,7 @@ class BOSMiner(BaseMiner):
                 return api_tunerstatus["TUNERSTATUS"][0][
                     "ApproximateMinerPowerConsumption"
                 ]
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_wattage_limit(
@@ -781,7 +781,7 @@ class BOSMiner(BaseMiner):
         if api_tunerstatus:
             try:
                 return api_tunerstatus["TUNERSTATUS"][0]["PowerLimit"]
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_fans(
@@ -820,7 +820,7 @@ class BOSMiner(BaseMiner):
             for n in range(self.expected_fans):
                 try:
                     fans.append(Fan(api_fans["FANS"][n]["RPM"]))
-                except (IndexError, KeyError):
+                except LookupError:
                     pass
             return fans
         return [Fan() for _ in range(self.expected_fans)]
@@ -904,7 +904,7 @@ class BOSMiner(BaseMiner):
                             _error = _error[0].lower() + _error[1:]
                             errors.append(BraiinsOSError(f"Slot {_id} {_error}"))
                 return errors
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_fault_light(self, graphql_fault_light: dict = None) -> bool:
@@ -987,7 +987,7 @@ class BOSMiner(BaseMiner):
                     return round(
                         (sum(hr_list) / len(hr_list)) * self.expected_hashboards, 2
                     )
-            except (IndexError, KeyError):
+            except LookupError:
                 pass
 
     async def _is_mining(self, api_devdetails: dict = None) -> Optional[bool]:

pyasic/miners/backends/btminer.py

@@ -310,7 +310,7 @@ class BTMiner(BaseMiner):
             try:
                 mac = api_summary["SUMMARY"][0]["MAC"]
                 return str(mac).upper()
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_api_ver(self, api_get_version: dict = None) -> Optional[str]:
@@ -366,7 +366,7 @@ class BTMiner(BaseMiner):
                 self.fw_ver = api_summary["SUMMARY"][0]["Firmware Version"].replace(
                     "'", ""
                 )
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
         return self.fw_ver
@@ -398,7 +398,7 @@ class BTMiner(BaseMiner):
         if api_summary:
             try:
                 return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_hashboards(self, api_devs: dict = None) -> List[HashBoard]:
@@ -431,7 +431,7 @@ class BTMiner(BaseMiner):
                     hashboards[board["ASC"]].chips = board["Effective Chips"]
                     hashboards[board["ASC"]].serial_number = board["PCB SN"]
                     hashboards[board["ASC"]].missing = False
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
         return hashboards
@@ -446,7 +446,7 @@ class BTMiner(BaseMiner):
         if api_summary:
             try:
                 return api_summary["SUMMARY"][0]["Env Temp"]
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_wattage(self, api_summary: dict = None) -> Optional[int]:
@@ -460,7 +460,7 @@ class BTMiner(BaseMiner):
             try:
                 wattage = api_summary["SUMMARY"][0]["Power"]
                 return wattage if not wattage == -1 else None
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_wattage_limit(self, api_summary: dict = None) -> Optional[int]:
@@ -473,7 +473,7 @@ class BTMiner(BaseMiner):
         if api_summary:
             try:
                 return api_summary["SUMMARY"][0]["Power Limit"]
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_fans(
@@ -493,7 +493,7 @@ class BTMiner(BaseMiner):
                         Fan(api_summary["SUMMARY"][0].get("Fan Speed In", 0)),
                         Fan(api_summary["SUMMARY"][0].get("Fan Speed Out", 0)),
                     ]
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
         return fans
@@ -510,7 +510,7 @@ class BTMiner(BaseMiner):
         if api_summary:
             try:
                 return int(api_summary["SUMMARY"][0]["Power Fanspeed"])
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
         if not api_get_psu:
@@ -555,7 +555,7 @@ class BTMiner(BaseMiner):
                     err = api_summary["SUMMARY"][0].get(f"Error Code {i}")
                     if err:
                         errors.append(WhatsminerError(error_code=err))
-            except (KeyError, IndexError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
         return errors
@@ -572,7 +572,7 @@ class BTMiner(BaseMiner):
                 expected_hashrate = api_summary["SUMMARY"][0]["Factory GHS"]
                 if expected_hashrate:
                     return round(expected_hashrate / 1000, 2)
-            except (KeyError, IndexError):
+            except LookupError:
                 pass
 
     async def _get_fault_light(self, api_get_miner_info: dict = None) -> bool:

pyasic/miners/backends/cgminer_avalon.py

@@ -208,7 +208,7 @@ class CGMinerAvalon(CGMiner):
         if api_devs:
             try:
                 return round(float(api_devs["DEVS"][0]["MHS 1m"] / 1000000), 2)
-            except (KeyError, IndexError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
     async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
@@ -227,7 +227,7 @@ class CGMinerAvalon(CGMiner):
             try:
                 unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-            except (IndexError, KeyError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 return hashboards
 
             for board in range(self.expected_hashboards):
@@ -271,7 +271,7 @@ class CGMinerAvalon(CGMiner):
                 unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
                 return round(float(parsed_stats["GHSmm"]) / 1000, 2)
-            except (IndexError, KeyError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
     async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]:
@@ -286,7 +286,7 @@ class CGMinerAvalon(CGMiner):
                 unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
                 return float(parsed_stats["Temp"])
-            except (IndexError, KeyError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
     async def _get_wattage(self) -> Optional[int]:
@@ -304,7 +304,7 @@ class CGMinerAvalon(CGMiner):
                 unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
                 return int(parsed_stats["MPO"])
-            except (IndexError, KeyError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
     async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
@@ -325,7 +325,7 @@ class CGMinerAvalon(CGMiner):
             for fan in range(self.expected_fans):
                 try:
                     fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"])
-                except (IndexError, KeyError, ValueError, TypeError):
+                except (LookupError, ValueError, TypeError):
                     pass
         return fans_data
 
@@ -347,7 +347,7 @@ class CGMinerAvalon(CGMiner):
                 parsed_stats = self.parse_stats(unparsed_stats)
                 led = int(parsed_stats["Led"])
                 return True if led == 1 else False
-            except (IndexError, KeyError, ValueError, TypeError):
+            except (LookupError, ValueError, TypeError):
                 pass
 
         try:

pyasic/miners/backends/epic.py

@@ -216,7 +216,7 @@ class ePIC(BaseMiner):
 
                         hashrate += hb["Hashrate"][0] / ideal
                     return round(float(float(hashrate / 1000000)), 2)
-            except (IndexError, KeyError, ValueError, TypeError) as e:
+            except (LookupError, ValueError, TypeError) as e:
                 logger.error(e)
                 pass