diff --git a/pyasic/miners/backends/btminer.py b/pyasic/miners/backends/btminer.py index de3ef732..f647077e 100644 --- a/pyasic/miners/backends/btminer.py +++ b/pyasic/miners/backends/btminer.py @@ -35,74 +35,73 @@ from pyasic.miners.base import ( BTMINER_DATA_LOC = DataLocations( **{ str(DataOptions.MAC): DataFunction( - "get_mac", + "_get_mac", [ RPCAPICommand("api_summary", "summary"), RPCAPICommand("api_get_miner_info", "get_miner_info"), ], ), - str(DataOptions.MODEL): DataFunction("get_model"), str(DataOptions.API_VERSION): DataFunction( - "get_api_ver", [RPCAPICommand("api_get_version", "get_version")] + "_get_api_ver", [RPCAPICommand("api_get_version", "get_version")] ), str(DataOptions.FW_VERSION): DataFunction( - "get_fw_ver", + "_get_fw_ver", [ RPCAPICommand("api_get_version", "get_version"), RPCAPICommand("api_summary", "summary"), ], ), str(DataOptions.HOSTNAME): DataFunction( - "get_hostname", [RPCAPICommand("api_get_miner_info", "get_miner_info")] + "_get_hostname", [RPCAPICommand("api_get_miner_info", "get_miner_info")] ), str(DataOptions.HASHRATE): DataFunction( - "get_hashrate", [RPCAPICommand("api_summary", "summary")] + "_get_hashrate", [RPCAPICommand("api_summary", "summary")] ), str(DataOptions.EXPECTED_HASHRATE): DataFunction( - "get_expected_hashrate", [RPCAPICommand("api_summary", "summary")] + "_get_expected_hashrate", [RPCAPICommand("api_summary", "summary")] ), str(DataOptions.HASHBOARDS): DataFunction( - "get_hashboards", [RPCAPICommand("api_devs", "devs")] + "_get_hashboards", [RPCAPICommand("api_devs", "devs")] ), str(DataOptions.ENVIRONMENT_TEMP): DataFunction( - "get_env_temp", [RPCAPICommand("api_summary", "summary")] + "_get_env_temp", [RPCAPICommand("api_summary", "summary")] ), str(DataOptions.WATTAGE): DataFunction( - "get_wattage", [RPCAPICommand("api_summary", "summary")] + "_get_wattage", [RPCAPICommand("api_summary", "summary")] ), str(DataOptions.WATTAGE_LIMIT): DataFunction( - "get_wattage_limit", [RPCAPICommand("api_summary", "summary")] + "_get_wattage_limit", [RPCAPICommand("api_summary", "summary")] ), str(DataOptions.FANS): DataFunction( - "get_fans", + "_get_fans", [ RPCAPICommand("api_summary", "summary"), RPCAPICommand("api_get_psu", "get_psu"), ], ), str(DataOptions.FAN_PSU): DataFunction( - "get_fan_psu", + "_get_fan_psu", [ RPCAPICommand("api_summary", "summary"), RPCAPICommand("api_get_psu", "get_psu"), ], ), str(DataOptions.ERRORS): DataFunction( - "get_errors", + "_get_errors", [ RPCAPICommand("api_get_error_code", "get_error_code"), RPCAPICommand("api_summary", "summary"), ], ), str(DataOptions.FAULT_LIGHT): DataFunction( - "get_fault_light", + "_get_fault_light", [RPCAPICommand("api_get_miner_info", "get_miner_info")], ), str(DataOptions.IS_MINING): DataFunction( - "is_mining", [RPCAPICommand("api_status", "status")] + "_is_mining", [RPCAPICommand("api_status", "status")] ), str(DataOptions.UPTIME): DataFunction( - "get_uptime", [RPCAPICommand("api_summary", "summary")] + "_get_uptime", [RPCAPICommand("api_summary", "summary")] ), str(DataOptions.CONFIG): DataFunction("get_config"), } @@ -243,7 +242,7 @@ class BTMiner(BaseMiner): else: cfg = MinerConfig() - is_mining = await self.is_mining(status) + is_mining = await self._is_mining(status) if not is_mining: cfg.mining_mode = MiningModeConfig.sleep() return cfg @@ -287,7 +286,7 @@ class BTMiner(BaseMiner): ### DATA GATHERING FUNCTIONS (get_{some_data}) ### ################################################## - async def get_mac( + async def _get_mac( self, api_summary: dict = None, api_get_miner_info: dict = None ) -> Optional[str]: if not api_get_miner_info: @@ -316,21 +315,7 @@ class BTMiner(BaseMiner): except (KeyError, IndexError): pass - async def get_version( - self, api_get_version: dict = None, api_summary: dict = None - ) -> Tuple[Optional[str], Optional[str]]: - miner_version = namedtuple("MinerVersion", "api_ver fw_ver") - api_ver = await self.get_api_ver(api_get_version=api_get_version) - fw_ver = await self.get_fw_ver( - api_get_version=api_get_version, api_summary=api_summary - ) - return miner_version(api_ver, fw_ver) - - async def get_api_ver(self, api_get_version: dict = None) -> Optional[str]: - # Check to see if the version info is already cached - if self.api_ver: - return self.api_ver - + async def _get_api_ver(self, api_get_version: dict = None) -> Optional[str]: if not api_get_version: try: api_get_version = await self.api.get_version() @@ -353,13 +338,9 @@ class BTMiner(BaseMiner): return self.api_ver - async def get_fw_ver( + async def _get_fw_ver( self, api_get_version: dict = None, api_summary: dict = None ) -> Optional[str]: - # Check to see if the version info is already cached - if self.fw_ver: - return self.fw_ver - if not api_get_version: try: api_get_version = await self.api.get_version() @@ -392,7 +373,7 @@ class BTMiner(BaseMiner): return self.fw_ver - async def get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]: + async def _get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]: hostname = None if not api_get_miner_info: try: @@ -408,7 +389,7 @@ class BTMiner(BaseMiner): return hostname - async def get_hashrate(self, api_summary: dict = None) -> Optional[float]: + async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: # get hr from API if not api_summary: try: @@ -422,7 +403,7 @@ class BTMiner(BaseMiner): except (KeyError, IndexError): pass - async def get_hashboards(self, api_devs: dict = None) -> List[HashBoard]: + async def _get_hashboards(self, api_devs: dict = None) -> List[HashBoard]: hashboards = [ HashBoard(slot=i, expected_chips=self.expected_chips) for i in range(self.expected_hashboards) @@ -457,7 +438,7 @@ class BTMiner(BaseMiner): return hashboards - async def get_env_temp(self, api_summary: dict = None) -> Optional[float]: + async def _get_env_temp(self, api_summary: dict = None) -> Optional[float]: if not api_summary: try: api_summary = await self.api.summary() @@ -470,7 +451,7 @@ class BTMiner(BaseMiner): except (KeyError, IndexError): pass - async def get_wattage(self, api_summary: dict = None) -> Optional[int]: + async def _get_wattage(self, api_summary: dict = None) -> Optional[int]: if not api_summary: try: api_summary = await self.api.summary() @@ -484,7 +465,7 @@ class BTMiner(BaseMiner): except (KeyError, IndexError): pass - async def get_wattage_limit(self, api_summary: dict = None) -> Optional[int]: + async def _get_wattage_limit(self, api_summary: dict = None) -> Optional[int]: if not api_summary: try: api_summary = await self.api.summary() @@ -497,7 +478,7 @@ class BTMiner(BaseMiner): except (KeyError, IndexError): pass - async def get_fans( + async def _get_fans( self, api_summary: dict = None, api_get_psu: dict = None ) -> List[Fan]: if not api_summary: @@ -506,10 +487,10 @@ class BTMiner(BaseMiner): except APIError: pass - fans = [Fan() for _ in range(self.fan_count)] + fans = [Fan() for _ in range(self.expected_fans)] if api_summary: try: - if self.fan_count > 0: + if self.expected_fans > 0: fans = [ Fan(api_summary["SUMMARY"][0].get("Fan Speed In", 0)), Fan(api_summary["SUMMARY"][0].get("Fan Speed Out", 0)), @@ -519,7 +500,7 @@ class BTMiner(BaseMiner): return fans - async def get_fan_psu( + async def _get_fan_psu( self, api_summary: dict = None, api_get_psu: dict = None ) -> Optional[int]: if not api_summary: @@ -546,7 +527,7 @@ class BTMiner(BaseMiner): except (KeyError, TypeError): pass - async def get_errors( + async def _get_errors( self, api_summary: dict = None, api_get_error_code: dict = None ) -> List[MinerErrorData]: errors = [] @@ -581,7 +562,7 @@ class BTMiner(BaseMiner): return errors - async def get_expected_hashrate(self, api_summary: dict = None): + async def _get_expected_hashrate(self, api_summary: dict = None): if not api_summary: try: api_summary = await self.api.summary() @@ -596,7 +577,7 @@ class BTMiner(BaseMiner): except (KeyError, IndexError): pass - async def get_fault_light(self, api_get_miner_info: dict = None) -> bool: + async def _get_fault_light(self, api_get_miner_info: dict = None) -> bool: if not api_get_miner_info: try: api_get_miner_info = await self.api.get_miner_info() @@ -634,7 +615,7 @@ class BTMiner(BaseMiner): async def set_hostname(self, hostname: str): await self.api.set_hostname(hostname) - async def is_mining(self, api_status: dict = None) -> Optional[bool]: + async def _is_mining(self, api_status: dict = None) -> Optional[bool]: if not api_status: try: api_status = await self.api.status() @@ -653,7 +634,7 @@ class BTMiner(BaseMiner): except LookupError: pass - async def get_uptime(self, api_summary: dict = None) -> Optional[int]: + async def _get_uptime(self, api_summary: dict = None) -> Optional[int]: if not api_summary: try: api_summary = await self.api.summary() diff --git a/pyasic/miners/backends/cgminer_avalon.py b/pyasic/miners/backends/cgminer_avalon.py index 216087b5..51e34ff7 100644 --- a/pyasic/miners/backends/cgminer_avalon.py +++ b/pyasic/miners/backends/cgminer_avalon.py @@ -28,42 +28,41 @@ from pyasic.miners.base import DataFunction, DataLocations, DataOptions, RPCAPIC AVALON_DATA_LOC = DataLocations( **{ str(DataOptions.MAC): DataFunction( - "get_mac", [RPCAPICommand("api_version", "version")] + "_get_mac", [RPCAPICommand("api_version", "version")] ), - str(DataOptions.MODEL): DataFunction("get_model"), str(DataOptions.API_VERSION): DataFunction( - "get_api_ver", [RPCAPICommand("api_version", "version")] + "_get_api_ver", [RPCAPICommand("api_version", "version")] ), str(DataOptions.FW_VERSION): DataFunction( - "get_fw_ver", [RPCAPICommand("api_version", "version")] + "_get_fw_ver", [RPCAPICommand("api_version", "version")] ), - str(DataOptions.HOSTNAME): DataFunction("get_hostname"), + str(DataOptions.HOSTNAME): DataFunction("_get_hostname"), str(DataOptions.HASHRATE): DataFunction( - "get_hashrate", [RPCAPICommand("api_devs", "devs")] + "_get_hashrate", [RPCAPICommand("api_devs", "devs")] ), str(DataOptions.EXPECTED_HASHRATE): DataFunction( - "get_expected_hashrate", [RPCAPICommand("api_stats", "stats")] + "_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")] ), str(DataOptions.HASHBOARDS): DataFunction( - "get_hashboards", [RPCAPICommand("api_stats", "stats")] + "_get_hashboards", [RPCAPICommand("api_stats", "stats")] ), str(DataOptions.ENVIRONMENT_TEMP): DataFunction( - "get_env_temp", [RPCAPICommand("api_stats", "stats")] + "_get_env_temp", [RPCAPICommand("api_stats", "stats")] ), - str(DataOptions.WATTAGE): DataFunction("get_wattage"), + str(DataOptions.WATTAGE): DataFunction("_get_wattage"), str(DataOptions.WATTAGE_LIMIT): DataFunction( - "get_wattage_limit", [RPCAPICommand("api_stats", "stats")] + "_get_wattage_limit", [RPCAPICommand("api_stats", "stats")] ), str(DataOptions.FANS): DataFunction( - "get_fans", [RPCAPICommand("api_stats", "stats")] + "_get_fans", [RPCAPICommand("api_stats", "stats")] ), - str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"), - str(DataOptions.ERRORS): DataFunction("get_errors"), + str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"), + str(DataOptions.ERRORS): DataFunction("_get_errors"), str(DataOptions.FAULT_LIGHT): DataFunction( - "get_fault_light", [RPCAPICommand("api_stats", "stats")] + "_get_fault_light", [RPCAPICommand("api_stats", "stats")] ), - str(DataOptions.IS_MINING): DataFunction("is_mining"), - str(DataOptions.UPTIME): DataFunction("get_uptime"), + str(DataOptions.IS_MINING): DataFunction("_is_mining"), + str(DataOptions.UPTIME): DataFunction("_get_uptime"), str(DataOptions.CONFIG): DataFunction("get_config"), } ) @@ -174,7 +173,7 @@ class CGMinerAvalon(CGMiner): ### DATA GATHERING FUNCTIONS (get_{some_data}) ### ################################################## - async def get_mac(self, api_version: dict = None) -> Optional[str]: + async def _get_mac(self, api_version: dict = None) -> Optional[str]: if not api_version: try: api_version = await self.api.version() @@ -192,7 +191,7 @@ class CGMinerAvalon(CGMiner): except (KeyError, ValueError): pass - async def get_hostname(self) -> Optional[str]: + async def _get_hostname(self) -> Optional[str]: return None # if not mac: # mac = await self.get_mac() @@ -200,7 +199,7 @@ class CGMinerAvalon(CGMiner): # if mac: # return f"Avalon{mac.replace(':', '')[-6:]}" - async def get_hashrate(self, api_devs: dict = None) -> Optional[float]: + async def _get_hashrate(self, api_devs: dict = None) -> Optional[float]: if not api_devs: try: api_devs = await self.api.devs() @@ -213,7 +212,7 @@ class CGMinerAvalon(CGMiner): except (KeyError, IndexError, ValueError, TypeError): pass - async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: + async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: hashboards = [ HashBoard(slot=i, expected_chips=self.expected_chips) for i in range(self.expected_hashboards) @@ -261,7 +260,7 @@ class CGMinerAvalon(CGMiner): return hashboards - async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: + async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: if not api_stats: try: api_stats = await self.api.stats() @@ -276,7 +275,7 @@ class CGMinerAvalon(CGMiner): except (IndexError, KeyError, ValueError, TypeError): pass - async def get_env_temp(self, api_stats: dict = None) -> Optional[float]: + async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]: if not api_stats: try: api_stats = await self.api.stats() @@ -291,10 +290,10 @@ class CGMinerAvalon(CGMiner): except (IndexError, KeyError, ValueError, TypeError): pass - async def get_wattage(self) -> Optional[int]: + async def _get_wattage(self) -> Optional[int]: return None - async def get_wattage_limit(self, api_stats: dict = None) -> Optional[int]: + async def _get_wattage_limit(self, api_stats: dict = None) -> Optional[int]: if not api_stats: try: api_stats = await self.api.stats() @@ -309,14 +308,14 @@ class CGMinerAvalon(CGMiner): except (IndexError, KeyError, ValueError, TypeError): pass - async def get_fans(self, api_stats: dict = None) -> List[Fan]: + async def _get_fans(self, api_stats: dict = None) -> List[Fan]: if not api_stats: try: api_stats = await self.api.stats() except APIError: pass - fans_data = [Fan() for _ in range(self.fan_count)] + fans_data = [Fan() for _ in range(self.expected_fans)] if api_stats: try: unparsed_stats = api_stats["STATS"][0]["MM ID0"] @@ -324,17 +323,17 @@ class CGMinerAvalon(CGMiner): except LookupError: return fans_data - for fan in range(self.fan_count): + for fan in range(self.expected_fans): try: fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"]) except (IndexError, KeyError, ValueError, TypeError): pass return fans_data - async def get_errors(self) -> List[MinerErrorData]: + async def _get_errors(self) -> List[MinerErrorData]: return [] - async def get_fault_light(self, api_stats: dict = None) -> bool: # noqa + async def _get_fault_light(self, api_stats: dict = None) -> bool: # noqa if self.light: return self.light if not api_stats: @@ -363,7 +362,7 @@ class CGMinerAvalon(CGMiner): pass return False - async def is_mining(self, *args, **kwargs) -> Optional[bool]: + async def _is_mining(self, *args, **kwargs) -> Optional[bool]: return None async def get_uptime(self) -> Optional[int]: diff --git a/pyasic/miners/backends/hiveon.py b/pyasic/miners/backends/hiveon.py index 600eb41c..7cc6cfd7 100644 --- a/pyasic/miners/backends/hiveon.py +++ b/pyasic/miners/backends/hiveon.py @@ -68,14 +68,10 @@ class Hiveon(BMMiner): self.pwd = "admin" # static data self.api_type = "Hiveon" + self.fw_str = "Hive" # data gathering locations self.data_locations = HIVEON_DATA_LOC - async def get_model(self) -> Optional[str]: - if self.model is not None: - return self.model + " (Hiveon)" - return "? (Hiveon)" - async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: pass