CAT_TOM/pyasic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: rename miner.api to miner.rpc. Add miner.api property linked to miner.rpc.

Browse Source
This commit is contained in:
UpstreamData
2024-01-26 10:15:20 -07:00
parent c2b6cc7468
commit 96aa346f00
15 changed files with 672 additions and 659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
pyasic/miners/antminer/hiveon/X9/T9.py
View File

@@ -28,39 +28,39 @@ HIVEON_T9_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction( str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
"_get_env_temp", "_get_env_temp",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", "_get_wattage",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -84,15 +84,15 @@ class HiveonT9(Hiveon, T9):
except (TypeError, ValueError, asyncssh.Error, OSError, AttributeError): except (TypeError, ValueError, asyncssh.Error, OSError, AttributeError):
pass pass
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
hashboards = [ hashboards = [
HashBoard(slot=board, expected_chips=self.expected_chips) HashBoard(slot=board, expected_chips=self.expected_chips)
for board in range(self.expected_hashboards) for board in range(self.expected_hashboards)
] ]
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = self.api.stats() rpc_stats = self.rpc.stats()
except APIError: except APIError:
return [] return []
@@ -108,8 +108,8 @@ class HiveonT9(Hiveon, T9):
for chipset in board_map[board]: for chipset in board_map[board]:
if hashboards[board].chip_temp is None: if hashboards[board].chip_temp is None:
try: try:
hashboards[board].temp = api_stats["STATS"][1][f"temp{chipset}"] hashboards[board].temp = rpc_stats["STATS"][1][f"temp{chipset}"]
hashboards[board].chip_temp = api_stats["STATS"][1][ hashboards[board].chip_temp = rpc_stats["STATS"][1][
f"temp2_{chipset}" f"temp2_{chipset}"
] ]
except (KeyError, IndexError): except (KeyError, IndexError):
@@ -117,8 +117,8 @@ class HiveonT9(Hiveon, T9):
else: else:
hashboards[board].missing = False hashboards[board].missing = False
try: try:
hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"] hashrate += rpc_stats["STATS"][1][f"chain_rate{chipset}"]
chips += api_stats["STATS"][1][f"chain_acn{chipset}"] chips += rpc_stats["STATS"][1][f"chain_acn{chipset}"]
except (KeyError, IndexError): except (KeyError, IndexError):
pass pass
hashboards[board].hashrate = round(hashrate / 1000, 2) hashboards[board].hashrate = round(hashrate / 1000, 2)
@@ -126,15 +126,15 @@ class HiveonT9(Hiveon, T9):
return hashboards return hashboards
async def _get_wattage(self, api_stats: dict = None) -> Optional[int]: async def _get_wattage(self, rpc_stats: dict = None) -> Optional[int]:
if not api_stats: if not rpc_stats:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats: if rpc_stats:
boards = api_stats.get("STATS") boards = rpc_stats.get("STATS")
try: try:
wattage_raw = boards[1]["chain_power"] wattage_raw = boards[1]["chain_power"]
except (KeyError, IndexError): except (KeyError, IndexError):
@@ -143,23 +143,23 @@ class HiveonT9(Hiveon, T9):
# parse wattage position out of raw data # parse wattage position out of raw data
return round(float(wattage_raw.split(" ")[0])) return round(float(wattage_raw.split(" ")[0]))
async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]: async def _get_env_temp(self, rpc_stats: dict = None) -> Optional[float]:
env_temp_list = [] env_temp_list = []
board_map = { board_map = {
0: [2, 9, 10], 0: [2, 9, 10],
1: [3, 11, 12], 1: [3, 11, 12],
2: [4, 13, 14], 2: [4, 13, 14],
} }
if not api_stats: if not rpc_stats:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats: if rpc_stats:
for board in board_map.values(): for board in board_map.values():
for chipset in board: for chipset in board:
try: try:
env_temp = api_stats["STATS"][1][f"temp3_{chipset}"] env_temp = rpc_stats["STATS"][1][f"temp3_{chipset}"]
if not env_temp == 0: if not env_temp == 0:
env_temp_list.append(int(env_temp)) env_temp_list.append(int(env_temp))
except (KeyError, IndexError): except (KeyError, IndexError):

92
pyasic/miners/backends/antminer.py
View File

@@ -40,11 +40,11 @@ ANTMINER_MODERN_DATA_LOC = DataLocations(
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HOSTNAME): DataFunction( str(DataOptions.HOSTNAME): DataFunction(
"_get_hostname", "_get_hostname",
@@ -52,15 +52,15 @@ ANTMINER_MODERN_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.ERRORS): DataFunction( str(DataOptions.ERRORS): DataFunction(
"_get_errors", "_get_errors",
@@ -76,7 +76,7 @@ ANTMINER_MODERN_DATA_LOC = DataLocations(
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -206,13 +206,13 @@ class AntminerModern(BMMiner):
] ]
try: try:
api_stats = await self.api.send_command("stats", new_api=True) rpc_stats = await self.rpc.send_command("stats", new_rpc=True)
except APIError: except APIError:
return hashboards return hashboards
if api_stats is not None: if rpc_stats is not None:
try: try:
for board in api_stats["STATS"][0]["chain"]: for board in rpc_stats["STATS"][0]["chain"]:
hashboards[board["index"]].hashrate = round( hashboards[board["index"]].hashrate = round(
board["rate_real"] / 1000, 2 board["rate_real"] / 1000, 2
) )
@@ -254,18 +254,18 @@ class AntminerModern(BMMiner):
pass pass
return self.light return self.light
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_stats: dict = None) -> Optional[float]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
expected_rate = api_stats["STATS"][1]["total_rateideal"] expected_rate = rpc_stats["STATS"][1]["total_rateideal"]
try: try:
rate_unit = api_stats["STATS"][1]["rate_unit"] rate_unit = rpc_stats["STATS"][1]["rate_unit"]
except KeyError: except KeyError:
rate_unit = "GH" rate_unit = "GH"
if rate_unit == "GH": if rate_unit == "GH":
@@ -336,16 +336,16 @@ class AntminerModern(BMMiner):
except LookupError: except LookupError:
pass pass
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_stats: dict = None) -> Optional[int]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
return int(api_stats["STATS"][1]["Elapsed"]) return int(rpc_stats["STATS"][1]["Elapsed"])
except LookupError: except LookupError:
pass pass
@@ -354,11 +354,11 @@ ANTMINER_OLD_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HOSTNAME): DataFunction( str(DataOptions.HOSTNAME): DataFunction(
"_get_hostname", "_get_hostname",
@@ -366,15 +366,15 @@ ANTMINER_OLD_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FAULT_LIGHT): DataFunction( str(DataOptions.FAULT_LIGHT): DataFunction(
"_get_fault_light", "_get_fault_light",
@@ -386,7 +386,7 @@ ANTMINER_OLD_DATA_LOC = DataLocations(
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -479,47 +479,47 @@ class AntminerOld(CGMiner):
except KeyError: except KeyError:
pass pass
async def _get_fans(self, api_stats: dict = None) -> List[Fan]: async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
fans_data = [Fan() for _ in range(self.expected_fans)] fans_data = [Fan() for _ in range(self.expected_fans)]
if api_stats is not None: if rpc_stats is not None:
try: try:
fan_offset = -1 fan_offset = -1
for fan_num in range(1, 8, 4): for fan_num in range(1, 8, 4):
for _f_num in range(4): for _f_num in range(4):
f = api_stats["STATS"][1].get(f"fan{fan_num + _f_num}") f = rpc_stats["STATS"][1].get(f"fan{fan_num + _f_num}")
if f and not f == 0 and fan_offset == -1: if f and not f == 0 and fan_offset == -1:
fan_offset = fan_num + 2 fan_offset = fan_num + 2
if fan_offset == -1: if fan_offset == -1:
fan_offset = 3 fan_offset = 3
for fan in range(self.expected_fans): for fan in range(self.expected_fans):
fans_data[fan].speed = api_stats["STATS"][1].get( fans_data[fan].speed = rpc_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0 f"fan{fan_offset+fan}", 0
) )
except LookupError: except LookupError:
pass pass
return fans_data return fans_data
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
hashboards = [] hashboards = []
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
board_offset = -1 board_offset = -1
boards = api_stats["STATS"] boards = rpc_stats["STATS"]
if len(boards) > 1: if len(boards) > 1:
for board_num in range(1, 16, 5): for board_num in range(1, 16, 5):
for _b_num in range(5): for _b_num in range(5):
@@ -574,27 +574,27 @@ class AntminerOld(CGMiner):
except LookupError: except LookupError:
pass pass
api_summary = None rpc_summary = None
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
if not api_summary == {}: if not rpc_summary == {}:
return True return True
else: else:
return False return False
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_stats: dict = None) -> Optional[int]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
return int(api_stats["STATS"][1]["Elapsed"]) return int(rpc_stats["STATS"][1]["Elapsed"])
except LookupError: except LookupError:
pass pass

52
pyasic/miners/backends/auradine.py
View File

@@ -47,12 +47,12 @@ AURADINE_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[ [
RPCAPICommand("api_devs", "devs"), RPCAPICommand("rpc_devs", "devs"),
WebAPICommand("web_ipreport", "ipreport"), WebAPICommand("web_ipreport", "ipreport"),
], ],
), ),
@@ -78,7 +78,7 @@ AURADINE_DATA_LOC = DataLocations(
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
} }
) )
@@ -116,8 +116,8 @@ class AuradineLEDCodes(Enum):
class Auradine(BaseMiner): class Auradine(BaseMiner):
"""Base handler for Auradine miners""" """Base handler for Auradine miners"""
_api_cls = GCMinerRPCAPI _rpc_cls = GCMinerRPCAPI
api: GCMinerRPCAPI rpc: GCMinerRPCAPI
_web_cls = AuradineWebAPI _web_cls = AuradineWebAPI
web: AuradineWebAPI web: AuradineWebAPI
@@ -127,10 +127,18 @@ class Auradine(BaseMiner):
supports_autotuning = True supports_autotuning = True
async def fault_light_on(self) -> bool: async def fault_light_on(self) -> bool:
return await self.web.set_led(code=int(AuradineLEDCodes.LOCATE_MINER)) try:
await self.web.set_led(code=int(AuradineLEDCodes.LOCATE_MINER))
return True
except APIError:
return False
async def fault_light_off(self) -> bool: async def fault_light_off(self) -> bool:
return await self.web.set_led(code=int(AuradineLEDCodes.NORMAL)) try:
await self.web.set_led(code=int(AuradineLEDCodes.NORMAL))
return True
except APIError:
return False
async def reboot(self) -> bool: async def reboot(self) -> bool:
try: try:
@@ -227,32 +235,32 @@ class Auradine(BaseMiner):
except LookupError: except LookupError:
pass pass
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round( return round(
float(float(api_summary["SUMMARY"][0]["MHS 5s"]) / 1000000), 2 float(float(rpc_summary["SUMMARY"][0]["MHS 5s"]) / 1000000), 2
) )
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
async def _get_hashboards( async def _get_hashboards(
self, api_devs: dict = None, web_ipreport: dict = None self, rpc_devs: dict = None, web_ipreport: dict = None
) -> List[HashBoard]: ) -> List[HashBoard]:
hashboards = [ hashboards = [
HashBoard(slot=i, expected_chips=self.expected_chips) HashBoard(slot=i, expected_chips=self.expected_chips)
for i in range(self.expected_hashboards) for i in range(self.expected_hashboards)
] ]
if api_devs is None: if rpc_devs is None:
try: try:
api_devs = await self.api.devs() rpc_devs = await self.rpc.devs()
except APIError: except APIError:
pass pass
if web_ipreport is None: if web_ipreport is None:
@@ -261,9 +269,9 @@ class Auradine(BaseMiner):
except APIError: except APIError:
pass pass
if api_devs is not None: if rpc_devs is not None:
try: try:
for board in api_devs["DEVS"]: for board in rpc_devs["DEVS"]:
b_id = board["ID"] - 1 b_id = board["ID"] - 1
hashboards[b_id].hashrate = round( hashboards[b_id].hashrate = round(
float(float(board["MHS 5s"]) / 1000000), 2 float(float(board["MHS 5s"]) / 1000000), 2
@@ -365,15 +373,15 @@ class Auradine(BaseMiner):
except (LookupError, TypeError, ValueError): except (LookupError, TypeError, ValueError):
pass pass
async def _get_uptime(self, api_summary: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_summary: dict = None) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return api_summary["SUMMARY"][0]["Elapsed"] return rpc_summary["SUMMARY"][0]["Elapsed"]
except LookupError: except LookupError:
pass pass

110
pyasic/miners/backends/avalonminer.py
View File

@@ -26,47 +26,47 @@ AVALON_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.MAC): DataFunction( str(DataOptions.MAC): DataFunction(
"_get_mac", "_get_mac",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_devs", "devs")], [RPCAPICommand("rpc_devs", "devs")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction( str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
"_get_env_temp", "_get_env_temp",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.WATTAGE_LIMIT): DataFunction( str(DataOptions.WATTAGE_LIMIT): DataFunction(
"_get_wattage_limit", "_get_wattage_limit",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FAULT_LIGHT): DataFunction( str(DataOptions.FAULT_LIGHT): DataFunction(
"_get_fault_light", "_get_fault_light",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -79,7 +79,7 @@ class AvalonMiner(CGMiner):
async def fault_light_on(self) -> bool: async def fault_light_on(self) -> bool:
try: try:
data = await self.api.ascset(0, "led", "1-1") data = await self.rpc.ascset(0, "led", "1-1")
except APIError: except APIError:
return False return False
if data["STATUS"][0]["Msg"] == "ASC 0 set OK": if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
@@ -88,7 +88,7 @@ class AvalonMiner(CGMiner):
async def fault_light_off(self) -> bool: async def fault_light_off(self) -> bool:
try: try:
data = await self.api.ascset(0, "led", "1-0") data = await self.rpc.ascset(0, "led", "1-0")
except APIError: except APIError:
return False return False
if data["STATUS"][0]["Msg"] == "ASC 0 set OK": if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
@@ -97,7 +97,7 @@ class AvalonMiner(CGMiner):
async def reboot(self) -> bool: async def reboot(self) -> bool:
try: try:
data = await self.api.restart() data = await self.rpc.restart()
except APIError: except APIError:
return False return False
@@ -155,16 +155,16 @@ class AvalonMiner(CGMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_mac(self, api_version: dict = None) -> Optional[str]: async def _get_mac(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
base_mac = api_version["VERSION"][0]["MAC"] base_mac = rpc_version["VERSION"][0]["MAC"]
base_mac = base_mac.upper() base_mac = base_mac.upper()
mac = ":".join( mac = ":".join(
[base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)] [base_mac[i : (i + 2)] for i in range(0, len(base_mac), 2)]
@@ -173,34 +173,34 @@ class AvalonMiner(CGMiner):
except (KeyError, ValueError): except (KeyError, ValueError):
pass pass
async def _get_hashrate(self, api_devs: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_devs: dict = None) -> Optional[float]:
if api_devs is None: if rpc_devs is None:
try: try:
api_devs = await self.api.devs() rpc_devs = await self.rpc.devs()
except APIError: except APIError:
pass pass
if api_devs is not None: if rpc_devs is not None:
try: try:
return round(float(api_devs["DEVS"][0]["MHS 1m"] / 1000000), 2) return round(float(rpc_devs["DEVS"][0]["MHS 1m"] / 1000000), 2)
except (KeyError, IndexError, ValueError, TypeError): except (KeyError, IndexError, ValueError, TypeError):
pass pass
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
hashboards = [ hashboards = [
HashBoard(slot=i, expected_chips=self.expected_chips) HashBoard(slot=i, expected_chips=self.expected_chips)
for i in range(self.expected_hashboards) for i in range(self.expected_hashboards)
] ]
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
except (IndexError, KeyError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
return hashboards return hashboards
@@ -234,62 +234,62 @@ class AvalonMiner(CGMiner):
return hashboards return hashboards
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_stats: dict = None) -> Optional[float]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
return round(float(parsed_stats["GHSmm"]) / 1000, 2) return round(float(parsed_stats["GHSmm"]) / 1000, 2)
except (IndexError, KeyError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]: async def _get_env_temp(self, rpc_stats: dict = None) -> Optional[float]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
return float(parsed_stats["Temp"]) return float(parsed_stats["Temp"])
except (IndexError, KeyError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
async def _get_wattage_limit(self, api_stats: dict = None) -> Optional[int]: async def _get_wattage_limit(self, rpc_stats: dict = None) -> Optional[int]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
return int(parsed_stats["MPO"]) return int(parsed_stats["MPO"])
except (IndexError, KeyError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
async def _get_fans(self, api_stats: dict = None) -> List[Fan]: async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
fans_data = [Fan() for _ in range(self.expected_fans)] fans_data = [Fan() for _ in range(self.expected_fans)]
if api_stats is not None: if rpc_stats is not None:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
except LookupError: except LookupError:
return fans_data return fans_data
@@ -301,18 +301,18 @@ class AvalonMiner(CGMiner):
pass pass
return fans_data return fans_data
async def _get_fault_light(self, api_stats: dict = None) -> Optional[bool]: async def _get_fault_light(self, rpc_stats: dict = None) -> Optional[bool]:
if self.light: if self.light:
return self.light return self.light
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
led = int(parsed_stats["Led"]) led = int(parsed_stats["Led"])
return True if led == 1 else False return True if led == 1 else False
@@ -320,7 +320,7 @@ class AvalonMiner(CGMiner):
pass pass
try: try:
data = await self.api.ascset(0, "led", "1-255") data = await self.rpc.ascset(0, "led", "1-255")
except APIError: except APIError:
return False return False
try: try:

86
pyasic/miners/backends/bfgminer.py
View File

@@ -27,27 +27,27 @@ BFGMINER_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -56,82 +56,82 @@ BFGMINER_DATA_LOC = DataLocations(
class BFGMiner(BaseMiner): class BFGMiner(BaseMiner):
"""Base handler for BFGMiner based miners.""" """Base handler for BFGMiner based miners."""
_api_cls = BFGMinerRPCAPI _rpc_cls = BFGMinerRPCAPI
api: BFGMinerRPCAPI rpc: BFGMinerRPCAPI
data_locations = BFGMINER_DATA_LOC data_locations = BFGMINER_DATA_LOC
async def get_config(self) -> MinerConfig: async def get_config(self) -> MinerConfig:
# get pool data # get pool data
try: try:
pools = await self.api.pools() pools = await self.rpc.pools()
except APIError: except APIError:
return self.config return self.config
self.config = MinerConfig.from_api(pools) self.config = MinerConfig.from_rpc(pools)
return self.config return self.config
################################################## ##################################################
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]: async def _get_api_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
self.api_ver = api_version["VERSION"][0]["API"] self.rpc_ver = rpc_version["VERSION"][0]["API"]
except LookupError: except LookupError:
pass pass
return self.api_ver return self.rpc_ver
async def _get_fw_ver(self, api_version: dict = None) -> Optional[str]: async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
self.fw_ver = api_version["VERSION"][0]["CompileTime"] self.fw_ver = rpc_version["VERSION"][0]["CompileTime"]
except LookupError: except LookupError:
pass pass
return self.fw_ver return self.fw_ver
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
# get hr from API # get hr from API
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["MHS 20s"] / 1000000), 2) return round(float(rpc_summary["SUMMARY"][0]["MHS 20s"] / 1000000), 2)
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
hashboards = [] hashboards = []
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
board_offset = -1 board_offset = -1
boards = api_stats["STATS"] boards = rpc_stats["STATS"]
if len(boards) > 1: if len(boards) > 1:
for board_num in range(1, 16, 5): for board_num in range(1, 16, 5):
for _b_num in range(5): for _b_num in range(5):
@@ -173,28 +173,28 @@ class BFGMiner(BaseMiner):
return hashboards return hashboards
async def _get_fans(self, api_stats: dict = None) -> List[Fan]: async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
fans_data = [None, None, None, None] fans_data = [None, None, None, None]
if api_stats is not None: if rpc_stats is not None:
try: try:
fan_offset = -1 fan_offset = -1
for fan_num in range(0, 8, 4): for fan_num in range(0, 8, 4):
for _f_num in range(4): for _f_num in range(4):
f = api_stats["STATS"][1].get(f"fan{fan_num + _f_num}", 0) f = rpc_stats["STATS"][1].get(f"fan{fan_num + _f_num}", 0)
if not f == 0 and fan_offset == -1: if not f == 0 and fan_offset == -1:
fan_offset = fan_num fan_offset = fan_num
if fan_offset == -1: if fan_offset == -1:
fan_offset = 1 fan_offset = 1
for fan in range(self.expected_fans): for fan in range(self.expected_fans):
fans_data[fan] = api_stats["STATS"][1].get( fans_data[fan] = rpc_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0 f"fan{fan_offset+fan}", 0
) )
except LookupError: except LookupError:
@@ -203,19 +203,19 @@ class BFGMiner(BaseMiner):
return fans return fans
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_stats: dict = None) -> Optional[float]:
# X19 method, not sure compatibility # X19 method, not sure compatibility
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
expected_rate = api_stats["STATS"][1]["total_rateideal"] expected_rate = rpc_stats["STATS"][1]["total_rateideal"]
try: try:
rate_unit = api_stats["STATS"][1]["rate_unit"] rate_unit = rpc_stats["STATS"][1]["rate_unit"]
except KeyError: except KeyError:
rate_unit = "GH" rate_unit = "GH"
if rate_unit == "GH": if rate_unit == "GH":

98
pyasic/miners/backends/bmminer.py
View File

@@ -27,31 +27,31 @@ BMMINER_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -60,82 +60,82 @@ BMMINER_DATA_LOC = DataLocations(
class BMMiner(BaseMiner): class BMMiner(BaseMiner):
"""Base handler for BMMiner based miners.""" """Base handler for BMMiner based miners."""
_api_cls = BMMinerRPCAPI _rpc_cls = BMMinerRPCAPI
api: BMMinerRPCAPI rpc: BMMinerRPCAPI
data_locations = BMMINER_DATA_LOC data_locations = BMMINER_DATA_LOC
async def get_config(self) -> MinerConfig: async def get_config(self) -> MinerConfig:
# get pool data # get pool data
try: try:
pools = await self.api.pools() pools = await self.rpc.pools()
except APIError: except APIError:
return self.config return self.config
self.config = MinerConfig.from_api(pools) self.config = MinerConfig.from_rpc(pools)
return self.config return self.config
################################################## ##################################################
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]: async def _get_api_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
self.api_ver = api_version["VERSION"][0]["API"] self.rpc_ver = rpc_version["VERSION"][0]["API"]
except LookupError: except LookupError:
pass pass
return self.api_ver return self.rpc_ver
async def _get_fw_ver(self, api_version: dict = None) -> Optional[str]: async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
self.fw_ver = api_version["VERSION"][0]["CompileTime"] self.fw_ver = rpc_version["VERSION"][0]["CompileTime"]
except LookupError: except LookupError:
pass pass
return self.fw_ver return self.fw_ver
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
# get hr from API # get hr from API
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["GHS 5s"] / 1000), 2) return round(float(rpc_summary["SUMMARY"][0]["GHS 5s"] / 1000), 2)
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
hashboards = [] hashboards = []
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
board_offset = -1 board_offset = -1
boards = api_stats["STATS"] boards = rpc_stats["STATS"]
if len(boards) > 1: if len(boards) > 1:
for board_num in range(1, 16, 5): for board_num in range(1, 16, 5):
for _b_num in range(5): for _b_num in range(5):
@@ -190,28 +190,28 @@ class BMMiner(BaseMiner):
return hashboards return hashboards
async def _get_fans(self, api_stats: dict = None) -> List[Fan]: async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
fans = [Fan() for _ in range(self.expected_fans)] fans = [Fan() for _ in range(self.expected_fans)]
if api_stats is not None: if rpc_stats is not None:
try: try:
fan_offset = -1 fan_offset = -1
for fan_num in range(1, 8, 4): for fan_num in range(1, 8, 4):
for _f_num in range(4): for _f_num in range(4):
f = api_stats["STATS"][1].get(f"fan{fan_num + _f_num}", 0) f = rpc_stats["STATS"][1].get(f"fan{fan_num + _f_num}", 0)
if f and not f == 0 and fan_offset == -1: if f and not f == 0 and fan_offset == -1:
fan_offset = fan_num fan_offset = fan_num
if fan_offset == -1: if fan_offset == -1:
fan_offset = 1 fan_offset = 1
for fan in range(self.expected_fans): for fan in range(self.expected_fans):
fans[fan].speed = api_stats["STATS"][1].get( fans[fan].speed = rpc_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0 f"fan{fan_offset+fan}", 0
) )
except LookupError: except LookupError:
@@ -219,19 +219,19 @@ class BMMiner(BaseMiner):
return fans return fans
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_stats: dict = None) -> Optional[float]:
# X19 method, not sure compatibility # X19 method, not sure compatibility
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
expected_rate = api_stats["STATS"][1]["total_rateideal"] expected_rate = rpc_stats["STATS"][1]["total_rateideal"]
try: try:
rate_unit = api_stats["STATS"][1]["rate_unit"] rate_unit = rpc_stats["STATS"][1]["rate_unit"]
except KeyError: except KeyError:
rate_unit = "GH" rate_unit = "GH"
if rate_unit == "GH": if rate_unit == "GH":
@@ -243,15 +243,15 @@ class BMMiner(BaseMiner):
except LookupError: except LookupError:
pass pass
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_stats: dict = None) -> Optional[int]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
return int(api_stats["STATS"][1]["Elapsed"]) return int(rpc_stats["STATS"][1]["Elapsed"])
except LookupError: except LookupError:
pass pass

244
pyasic/miners/backends/braiins_os.py
View File

@@ -44,7 +44,7 @@ BOSMINER_DATA_LOC = DataLocations(
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
@@ -52,43 +52,43 @@ BOSMINER_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_devs", "devs")], [RPCAPICommand("rpc_devs", "devs")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[ [
RPCAPICommand("api_temps", "temps"), RPCAPICommand("rpc_temps", "temps"),
RPCAPICommand("api_devdetails", "devdetails"), RPCAPICommand("rpc_devdetails", "devdetails"),
RPCAPICommand("api_devs", "devs"), RPCAPICommand("rpc_devs", "devs"),
], ],
), ),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", "_get_wattage",
[RPCAPICommand("api_tunerstatus", "tunerstatus")], [RPCAPICommand("rpc_tunerstatus", "tunerstatus")],
), ),
str(DataOptions.WATTAGE_LIMIT): DataFunction( str(DataOptions.WATTAGE_LIMIT): DataFunction(
"_get_wattage_limit", "_get_wattage_limit",
[RPCAPICommand("api_tunerstatus", "tunerstatus")], [RPCAPICommand("rpc_tunerstatus", "tunerstatus")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_fans", "fans")], [RPCAPICommand("rpc_fans", "fans")],
), ),
str(DataOptions.ERRORS): DataFunction( str(DataOptions.ERRORS): DataFunction(
"_get_errors", "_get_errors",
[RPCAPICommand("api_tunerstatus", "tunerstatus")], [RPCAPICommand("rpc_tunerstatus", "tunerstatus")],
), ),
str(DataOptions.IS_MINING): DataFunction( str(DataOptions.IS_MINING): DataFunction(
"_is_mining", "_is_mining",
[RPCAPICommand("api_devdetails", "devdetails")], [RPCAPICommand("rpc_devdetails", "devdetails")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
} }
) )
@@ -97,8 +97,8 @@ BOSMINER_DATA_LOC = DataLocations(
class BOSMiner(BaseMiner): class BOSMiner(BaseMiner):
"""Handler for old versions of BraiinsOS+ (pre-gRPC)""" """Handler for old versions of BraiinsOS+ (pre-gRPC)"""
_api_cls = BOSMinerRPCAPI _rpc_cls = BOSMinerRPCAPI
api: BOSMinerRPCAPI rpc: BOSMinerRPCAPI
_web_cls = BOSMinerWebAPI _web_cls = BOSMinerWebAPI
web: BOSMinerWebAPI web: BOSMinerWebAPI
_ssh_cls = BOSMinerSSH _ssh_cls = BOSMinerSSH
@@ -139,7 +139,7 @@ class BOSMiner(BaseMiner):
async def stop_mining(self) -> bool: async def stop_mining(self) -> bool:
try: try:
data = await self.api.pause() data = await self.rpc.pause()
except APIError: except APIError:
return False return False
@@ -150,7 +150,7 @@ class BOSMiner(BaseMiner):
async def resume_mining(self) -> bool: async def resume_mining(self) -> bool:
try: try:
data = await self.api.resume() data = await self.rpc.resume()
except APIError: except APIError:
return False return False
@@ -292,23 +292,23 @@ class BOSMiner(BaseMiner):
# if result: # if result:
# return result.upper().strip() # return result.upper().strip()
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]: async def _get_api_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
# Now get the API version # Now get the API version
if api_version is not None: if rpc_version is not None:
try: try:
api_ver = api_version["VERSION"][0]["API"] rpc_ver = rpc_version["VERSION"][0]["API"]
except LookupError: except LookupError:
api_ver = None rpc_ver = None
self.api_ver = api_ver self.rpc_ver = rpc_ver
self.api.api_ver = self.api_ver self.rpc.rpc_ver = self.rpc_ver
return self.api_ver return self.rpc_ver
async def _get_fw_ver(self, web_bos_info: dict = None) -> Optional[str]: async def _get_fw_ver(self, web_bos_info: dict = None) -> Optional[str]:
if web_bos_info is None: if web_bos_info is None:
@@ -340,24 +340,24 @@ class BOSMiner(BaseMiner):
return None return None
return hostname return hostname
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2) return round(float(rpc_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
except (KeyError, IndexError, ValueError, TypeError): except (KeyError, IndexError, ValueError, TypeError):
pass pass
async def _get_hashboards( async def _get_hashboards(
self, self,
api_temps: dict = None, rpc_temps: dict = None,
api_devdetails: dict = None, rpc_devdetails: dict = None,
api_devs: dict = None, rpc_devs: dict = None,
) -> List[HashBoard]: ) -> List[HashBoard]:
hashboards = [ hashboards = [
HashBoard(slot=i, expected_chips=self.expected_chips) HashBoard(slot=i, expected_chips=self.expected_chips)
@@ -365,34 +365,34 @@ class BOSMiner(BaseMiner):
] ]
cmds = [] cmds = []
if api_temps is None: if rpc_temps is None:
cmds.append("temps") cmds.append("temps")
if api_devdetails is None: if rpc_devdetails is None:
cmds.append("devdetails") cmds.append("devdetails")
if api_devs is None: if rpc_devs is None:
cmds.append("devs") cmds.append("devs")
if len(cmds) > 0: if len(cmds) > 0:
try: try:
d = await self.api.multicommand(*cmds) d = await self.rpc.multicommand(*cmds)
except APIError: except APIError:
d = {} d = {}
try: try:
api_temps = d["temps"][0] rpc_temps = d["temps"][0]
except LookupError: except LookupError:
api_temps = None rpc_temps = None
try: try:
api_devdetails = d["devdetails"][0] rpc_devdetails = d["devdetails"][0]
except (KeyError, IndexError): except (KeyError, IndexError):
api_devdetails = None rpc_devdetails = None
try: try:
api_devs = d["devs"][0] rpc_devs = d["devs"][0]
except LookupError: except LookupError:
api_devs = None rpc_devs = None
if api_temps is not None: if rpc_temps is not None:
try: try:
offset = 6 if api_temps["TEMPS"][0]["ID"] in [6, 7, 8] else 1 offset = 6 if rpc_temps["TEMPS"][0]["ID"] in [6, 7, 8] else 1
for board in api_temps["TEMPS"]: for board in rpc_temps["TEMPS"]:
_id = board["ID"] - offset _id = board["ID"] - offset
chip_temp = round(board["Chip"]) chip_temp = round(board["Chip"])
board_temp = round(board["Board"]) board_temp = round(board["Board"])
@@ -401,11 +401,11 @@ class BOSMiner(BaseMiner):
except (IndexError, KeyError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
if api_devdetails is not None: if rpc_devdetails is not None:
try: try:
offset = 6 if api_devdetails["DEVDETAILS"][0]["ID"] in [6, 7, 8] else 1 offset = 6 if rpc_devdetails["DEVDETAILS"][0]["ID"] in [6, 7, 8] else 1
for board in api_devdetails["DEVDETAILS"]: for board in rpc_devdetails["DEVDETAILS"]:
_id = board["ID"] - offset _id = board["ID"] - offset
chips = board["Chips"] chips = board["Chips"]
hashboards[_id].chips = chips hashboards[_id].chips = chips
@@ -413,11 +413,11 @@ class BOSMiner(BaseMiner):
except (IndexError, KeyError): except (IndexError, KeyError):
pass pass
if api_devs is not None: if rpc_devs is not None:
try: try:
offset = 6 if api_devs["DEVS"][0]["ID"] in [6, 7, 8] else 1 offset = 6 if rpc_devs["DEVS"][0]["ID"] in [6, 7, 8] else 1
for board in api_devs["DEVS"]: for board in rpc_devs["DEVS"]:
_id = board["ID"] - offset _id = board["ID"] - offset
hashrate = round(float(board["MHS 1m"] / 1000000), 2) hashrate = round(float(board["MHS 1m"] / 1000000), 2)
hashboards[_id].hashrate = hashrate hashboards[_id].hashrate = hashrate
@@ -426,62 +426,62 @@ class BOSMiner(BaseMiner):
return hashboards return hashboards
async def _get_wattage(self, api_tunerstatus: dict = None) -> Optional[int]: async def _get_wattage(self, rpc_tunerstatus: dict = None) -> Optional[int]:
if api_tunerstatus is None: if rpc_tunerstatus is None:
try: try:
api_tunerstatus = await self.api.tunerstatus() rpc_tunerstatus = await self.rpc.tunerstatus()
except APIError: except APIError:
pass pass
if api_tunerstatus is not None: if rpc_tunerstatus is not None:
try: try:
return api_tunerstatus["TUNERSTATUS"][0][ return rpc_tunerstatus["TUNERSTATUS"][0][
"ApproximateMinerPowerConsumption" "ApproximateMinerPowerConsumption"
] ]
except LookupError: except LookupError:
pass pass
async def _get_wattage_limit(self, api_tunerstatus: dict = None) -> Optional[int]: async def _get_wattage_limit(self, rpc_tunerstatus: dict = None) -> Optional[int]:
if api_tunerstatus is None: if rpc_tunerstatus is None:
try: try:
api_tunerstatus = await self.api.tunerstatus() rpc_tunerstatus = await self.rpc.tunerstatus()
except APIError: except APIError:
pass pass
if api_tunerstatus is not None: if rpc_tunerstatus is not None:
try: try:
return api_tunerstatus["TUNERSTATUS"][0]["PowerLimit"] return rpc_tunerstatus["TUNERSTATUS"][0]["PowerLimit"]
except LookupError: except LookupError:
pass pass
async def _get_fans(self, api_fans: dict = None) -> List[Fan]: async def _get_fans(self, rpc_fans: dict = None) -> List[Fan]:
if api_fans is None: if rpc_fans is None:
try: try:
api_fans = await self.api.fans() rpc_fans = await self.rpc.fans()
except APIError: except APIError:
pass pass
if api_fans is not None: if rpc_fans is not None:
fans = [] fans = []
for n in range(self.expected_fans): for n in range(self.expected_fans):
try: try:
fans.append(Fan(api_fans["FANS"][n]["RPM"])) fans.append(Fan(rpc_fans["FANS"][n]["RPM"]))
except (IndexError, KeyError): except (IndexError, KeyError):
pass pass
return fans return fans
return [Fan() for _ in range(self.expected_fans)] return [Fan() for _ in range(self.expected_fans)]
async def _get_errors(self, api_tunerstatus: dict = None) -> List[MinerErrorData]: async def _get_errors(self, rpc_tunerstatus: dict = None) -> List[MinerErrorData]:
if api_tunerstatus is None: if rpc_tunerstatus is None:
try: try:
api_tunerstatus = await self.api.tunerstatus() rpc_tunerstatus = await self.rpc.tunerstatus()
except APIError: except APIError:
pass pass
if api_tunerstatus is not None: if rpc_tunerstatus is not None:
errors = [] errors = []
try: try:
chain_status = api_tunerstatus["TUNERSTATUS"][0]["TunerChainStatus"] chain_status = rpc_tunerstatus["TUNERSTATUS"][0]["TunerChainStatus"]
if chain_status and len(chain_status) > 0: if chain_status and len(chain_status) > 0:
offset = ( offset = (
6 if int(chain_status[0]["HashchainIndex"]) in [6, 7, 8] else 0 6 if int(chain_status[0]["HashchainIndex"]) in [6, 7, 8] else 0
@@ -513,18 +513,18 @@ class BOSMiner(BaseMiner):
except (TypeError, AttributeError): except (TypeError, AttributeError):
return self.light return self.light
async def _get_expected_hashrate(self, api_devs: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_devs: dict = None) -> Optional[float]:
if api_devs is None: if rpc_devs is None:
try: try:
api_devs = await self.api.devs() rpc_devs = await self.rpc.devs()
except APIError: except APIError:
pass pass
if api_devs is not None: if rpc_devs is not None:
try: try:
hr_list = [] hr_list = []
for board in api_devs["DEVS"]: for board in rpc_devs["DEVS"]:
expected_hashrate = round(float(board["Nominal MHS"] / 1000000), 2) expected_hashrate = round(float(board["Nominal MHS"] / 1000000), 2)
if expected_hashrate: if expected_hashrate:
hr_list.append(expected_hashrate) hr_list.append(expected_hashrate)
@@ -537,31 +537,31 @@ class BOSMiner(BaseMiner):
except (IndexError, KeyError): except (IndexError, KeyError):
pass pass
async def _is_mining(self, api_devdetails: dict = None) -> Optional[bool]: async def _is_mining(self, rpc_devdetails: dict = None) -> Optional[bool]:
if api_devdetails is None: if rpc_devdetails is None:
try: try:
api_devdetails = await self.api.send_command( rpc_devdetails = await self.rpc.send_command(
"devdetails", ignore_errors=True, allow_warning=False "devdetails", ignore_errors=True, allow_warning=False
) )
except APIError: except APIError:
pass pass
if api_devdetails is not None: if rpc_devdetails is not None:
try: try:
return not api_devdetails["STATUS"][0]["Msg"] == "Unavailable" return not rpc_devdetails["STATUS"][0]["Msg"] == "Unavailable"
except LookupError: except LookupError:
pass pass
async def _get_uptime(self, api_summary: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_summary: dict = None) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return int(api_summary["SUMMARY"][0]["Elapsed"]) return int(rpc_summary["SUMMARY"][0]["Elapsed"])
except LookupError: except LookupError:
pass pass
@@ -574,7 +574,7 @@ BOSER_DATA_LOC = DataLocations(
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
@@ -586,7 +586,7 @@ BOSER_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
@@ -614,7 +614,7 @@ BOSER_DATA_LOC = DataLocations(
), ),
str(DataOptions.ERRORS): DataFunction( str(DataOptions.ERRORS): DataFunction(
"_get_errors", "_get_errors",
[RPCAPICommand("api_tunerstatus", "tunerstatus")], [RPCAPICommand("rpc_tunerstatus", "tunerstatus")],
), ),
str(DataOptions.FAULT_LIGHT): DataFunction( str(DataOptions.FAULT_LIGHT): DataFunction(
"_get_fault_light", "_get_fault_light",
@@ -622,11 +622,11 @@ BOSER_DATA_LOC = DataLocations(
), ),
str(DataOptions.IS_MINING): DataFunction( str(DataOptions.IS_MINING): DataFunction(
"_is_mining", "_is_mining",
[RPCAPICommand("api_devdetails", "devdetails")], [RPCAPICommand("rpc_devdetails", "devdetails")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
} }
) )
@@ -635,7 +635,7 @@ BOSER_DATA_LOC = DataLocations(
class BOSer(BaseMiner): class BOSer(BaseMiner):
"""Handler for new versions of BraiinsOS+ (post-gRPC)""" """Handler for new versions of BraiinsOS+ (post-gRPC)"""
_api_cls = BOSMinerRPCAPI _rpc_cls = BOSMinerRPCAPI
web: BOSMinerRPCAPI web: BOSMinerRPCAPI
_web_cls = BOSerWebAPI _web_cls = BOSerWebAPI
web: BOSerWebAPI web: BOSerWebAPI
@@ -719,22 +719,22 @@ class BOSer(BaseMiner):
except (LookupError, TypeError): except (LookupError, TypeError):
pass pass
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]: async def _get_api_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
api_ver = api_version["VERSION"][0]["API"] rpc_ver = rpc_version["VERSION"][0]["API"]
except LookupError: except LookupError:
api_ver = None rpc_ver = None
self.api_ver = api_ver self.rpc_ver = rpc_ver
self.api.api_ver = self.api_ver self.rpc.rpc_ver = self.rpc_ver
return self.api_ver return self.rpc_ver
async def _get_fw_ver(self, grpc_miner_details: dict = None) -> Optional[str]: async def _get_fw_ver(self, grpc_miner_details: dict = None) -> Optional[str]:
if grpc_miner_details is None: if grpc_miner_details is None:
@@ -772,16 +772,16 @@ class BOSer(BaseMiner):
except LookupError: except LookupError:
pass pass
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2) return round(float(rpc_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
except (KeyError, IndexError, ValueError, TypeError): except (KeyError, IndexError, ValueError, TypeError):
pass pass
@@ -883,17 +883,17 @@ class BOSer(BaseMiner):
return fans return fans
return [Fan() for _ in range(self.expected_fans)] return [Fan() for _ in range(self.expected_fans)]
async def _get_errors(self, api_tunerstatus: dict = None) -> List[MinerErrorData]: async def _get_errors(self, rpc_tunerstatus: dict = None) -> List[MinerErrorData]:
if api_tunerstatus is None: if rpc_tunerstatus is None:
try: try:
api_tunerstatus = await self.api.tunerstatus() rpc_tunerstatus = await self.rpc.tunerstatus()
except APIError: except APIError:
pass pass
if api_tunerstatus is not None: if rpc_tunerstatus is not None:
errors = [] errors = []
try: try:
chain_status = api_tunerstatus["TUNERSTATUS"][0]["TunerChainStatus"] chain_status = rpc_tunerstatus["TUNERSTATUS"][0]["TunerChainStatus"]
if chain_status and len(chain_status) > 0: if chain_status and len(chain_status) > 0:
offset = ( offset = (
6 if int(chain_status[0]["HashchainIndex"]) in [6, 7, 8] else 0 6 if int(chain_status[0]["HashchainIndex"]) in [6, 7, 8] else 0
@@ -931,30 +931,30 @@ class BOSer(BaseMiner):
except LookupError: except LookupError:
pass pass
async def _is_mining(self, api_devdetails: dict = None) -> Optional[bool]: async def _is_mining(self, rpc_devdetails: dict = None) -> Optional[bool]:
if api_devdetails is None: if rpc_devdetails is None:
try: try:
api_devdetails = await self.api.send_command( rpc_devdetails = await self.rpc.send_command(
"devdetails", ignore_errors=True, allow_warning=False "devdetails", ignore_errors=True, allow_warning=False
) )
except APIError: except APIError:
pass pass
if api_devdetails is not None: if rpc_devdetails is not None:
try: try:
return not api_devdetails["STATUS"][0]["Msg"] == "Unavailable" return not rpc_devdetails["STATUS"][0]["Msg"] == "Unavailable"
except LookupError: except LookupError:
pass pass
async def _get_uptime(self, api_summary: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_summary: dict = None) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return int(api_summary["SUMMARY"][0]["Elapsed"]) return int(rpc_summary["SUMMARY"][0]["Elapsed"])
except LookupError: except LookupError:
pass pass

306
pyasic/miners/backends/btminer.py
View File

@@ -30,81 +30,81 @@ BTMINER_DATA_LOC = DataLocations(
str(DataOptions.MAC): DataFunction( str(DataOptions.MAC): DataFunction(
"_get_mac", "_get_mac",
[ [
RPCAPICommand("api_summary", "summary"), RPCAPICommand("rpc_summary", "summary"),
RPCAPICommand("api_get_miner_info", "get_miner_info"), RPCAPICommand("rpc_get_miner_info", "get_miner_info"),
], ],
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_get_version", "get_version")], [RPCAPICommand("rpc_get_version", "get_version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[ [
RPCAPICommand("api_get_version", "get_version"), RPCAPICommand("rpc_get_version", "get_version"),
RPCAPICommand("api_summary", "summary"), RPCAPICommand("rpc_summary", "summary"),
], ],
), ),
str(DataOptions.HOSTNAME): DataFunction( str(DataOptions.HOSTNAME): DataFunction(
"_get_hostname", "_get_hostname",
[RPCAPICommand("api_get_miner_info", "get_miner_info")], [RPCAPICommand("rpc_get_miner_info", "get_miner_info")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_devs", "devs")], [RPCAPICommand("rpc_devs", "devs")],
), ),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction( str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
"_get_env_temp", "_get_env_temp",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", "_get_wattage",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.WATTAGE_LIMIT): DataFunction( str(DataOptions.WATTAGE_LIMIT): DataFunction(
"_get_wattage_limit", "_get_wattage_limit",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[ [
RPCAPICommand("api_summary", "summary"), RPCAPICommand("rpc_summary", "summary"),
RPCAPICommand("api_get_psu", "get_psu"), RPCAPICommand("rpc_get_psu", "get_psu"),
], ],
), ),
str(DataOptions.FAN_PSU): DataFunction( str(DataOptions.FAN_PSU): DataFunction(
"_get_fan_psu", "_get_fan_psu",
[ [
RPCAPICommand("api_summary", "summary"), RPCAPICommand("rpc_summary", "summary"),
RPCAPICommand("api_get_psu", "get_psu"), RPCAPICommand("rpc_get_psu", "get_psu"),
], ],
), ),
str(DataOptions.ERRORS): DataFunction( str(DataOptions.ERRORS): DataFunction(
"_get_errors", "_get_errors",
[ [
RPCAPICommand("api_get_error_code", "get_error_code"), RPCAPICommand("rpc_get_error_code", "get_error_code"),
RPCAPICommand("api_summary", "summary"), RPCAPICommand("rpc_summary", "summary"),
], ],
), ),
str(DataOptions.FAULT_LIGHT): DataFunction( str(DataOptions.FAULT_LIGHT): DataFunction(
"_get_fault_light", "_get_fault_light",
[RPCAPICommand("api_get_miner_info", "get_miner_info")], [RPCAPICommand("rpc_get_miner_info", "get_miner_info")],
), ),
str(DataOptions.IS_MINING): DataFunction( str(DataOptions.IS_MINING): DataFunction(
"_is_mining", "_is_mining",
[RPCAPICommand("api_status", "status")], [RPCAPICommand("rpc_status", "status")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
} }
) )
@@ -113,16 +113,16 @@ BTMINER_DATA_LOC = DataLocations(
class BTMiner(BaseMiner): class BTMiner(BaseMiner):
"""Base handler for BTMiner based miners.""" """Base handler for BTMiner based miners."""
_api_cls = BTMinerRPCAPI _rpc_cls = BTMinerRPCAPI
api: BTMinerRPCAPI rpc: BTMinerRPCAPI
data_locations = BTMINER_DATA_LOC data_locations = BTMINER_DATA_LOC
supports_shutdown = True supports_shutdown = True
async def _reset_api_pwd_to_admin(self, pwd: str): async def _reset_rpc_pwd_to_admin(self, pwd: str):
try: try:
data = await self.api.update_pwd(pwd, "admin") data = await self.rpc.update_pwd(pwd, "admin")
except APIError: except APIError:
return False return False
if data: if data:
@@ -133,7 +133,7 @@ class BTMiner(BaseMiner):
async def fault_light_off(self) -> bool: async def fault_light_off(self) -> bool:
try: try:
data = await self.api.set_led(auto=True) data = await self.rpc.set_led(auto=True)
except APIError: except APIError:
return False return False
if data: if data:
@@ -145,8 +145,8 @@ class BTMiner(BaseMiner):
async def fault_light_on(self) -> bool: async def fault_light_on(self) -> bool:
try: try:
data = await self.api.set_led(auto=False) data = await self.rpc.set_led(auto=False)
await self.api.set_led( await self.rpc.set_led(
auto=False, color="green", start=0, period=1, duration=0 auto=False, color="green", start=0, period=1, duration=0
) )
except APIError: except APIError:
@@ -160,7 +160,7 @@ class BTMiner(BaseMiner):
async def reboot(self) -> bool: async def reboot(self) -> bool:
try: try:
data = await self.api.reboot() data = await self.rpc.reboot()
except APIError: except APIError:
return False return False
if data.get("Msg"): if data.get("Msg"):
@@ -170,7 +170,7 @@ class BTMiner(BaseMiner):
async def restart_backend(self) -> bool: async def restart_backend(self) -> bool:
try: try:
data = await self.api.restart() data = await self.rpc.restart()
except APIError: except APIError:
return False return False
if data.get("Msg"): if data.get("Msg"):
@@ -180,7 +180,7 @@ class BTMiner(BaseMiner):
async def stop_mining(self) -> bool: async def stop_mining(self) -> bool:
try: try:
data = await self.api.power_off(respbefore=True) data = await self.rpc.power_off(respbefore=True)
except APIError: except APIError:
return False return False
if data.get("Msg"): if data.get("Msg"):
@@ -190,7 +190,7 @@ class BTMiner(BaseMiner):
async def resume_mining(self) -> bool: async def resume_mining(self) -> bool:
try: try:
data = await self.api.power_on() data = await self.rpc.power_on()
except APIError: except APIError:
return False return False
if data.get("Msg"): if data.get("Msg"):
@@ -205,16 +205,16 @@ class BTMiner(BaseMiner):
pools_conf = conf["pools"] pools_conf = conf["pools"]
try: try:
await self.api.update_pools(**pools_conf) await self.rpc.update_pools(**pools_conf)
if conf["mode"] == "normal": if conf["mode"] == "normal":
await self.api.set_normal_power() await self.rpc.set_normal_power()
elif conf["mode"] == "high": elif conf["mode"] == "high":
await self.api.set_high_power() await self.rpc.set_high_power()
elif conf["mode"] == "low": elif conf["mode"] == "low":
await self.api.set_low_power() await self.rpc.set_low_power()
elif conf["mode"] == "power_tuning": elif conf["mode"] == "power_tuning":
await self.api.adjust_power_limit(conf["power_tuning"]["wattage"]) await self.rpc.adjust_power_limit(conf["power_tuning"]["wattage"])
except APIError: except APIError:
# cannot update, no API access usually # cannot update, no API access usually
pass pass
@@ -224,7 +224,7 @@ class BTMiner(BaseMiner):
summary = None summary = None
status = None status = None
try: try:
data = await self.api.multicommand("pools", "summary", "status") data = await self.rpc.multicommand("pools", "summary", "status")
pools = data["pools"][0] pools = data["pools"][0]
summary = data["summary"][0] summary = data["summary"][0]
status = data["status"][0] status = data["status"][0]
@@ -234,7 +234,7 @@ class BTMiner(BaseMiner):
pass pass
if pools is not None: if pools is not None:
cfg = MinerConfig.from_api(pools) cfg = MinerConfig.from_rpc(pools)
else: else:
cfg = MinerConfig() cfg = MinerConfig()
@@ -271,7 +271,7 @@ class BTMiner(BaseMiner):
async def set_power_limit(self, wattage: int) -> bool: async def set_power_limit(self, wattage: int) -> bool:
try: try:
await self.api.adjust_power_limit(wattage) await self.rpc.adjust_power_limit(wattage)
except Exception as e: except Exception as e:
logging.warning(f"{self} set_power_limit: {e}") logging.warning(f"{self} set_power_limit: {e}")
return False return False
@@ -283,85 +283,85 @@ class BTMiner(BaseMiner):
################################################## ##################################################
async def _get_mac( async def _get_mac(
self, api_summary: dict = None, api_get_miner_info: dict = None self, rpc_summary: dict = None, rpc_get_miner_info: dict = None
) -> Optional[str]: ) -> Optional[str]:
if api_get_miner_info is None: if rpc_get_miner_info is None:
try: try:
api_get_miner_info = await self.api.get_miner_info() rpc_get_miner_info = await self.rpc.get_miner_info()
except APIError: except APIError:
pass pass
if api_get_miner_info is not None: if rpc_get_miner_info is not None:
try: try:
mac = api_get_miner_info["Msg"]["mac"] mac = rpc_get_miner_info["Msg"]["mac"]
return str(mac).upper() return str(mac).upper()
except KeyError: except KeyError:
pass pass
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
mac = api_summary["SUMMARY"][0]["MAC"] mac = rpc_summary["SUMMARY"][0]["MAC"]
return str(mac).upper() return str(mac).upper()
except LookupError: except LookupError:
pass pass
async def _get_api_ver(self, api_get_version: dict = None) -> Optional[str]: async def _get_api_ver(self, rpc_get_version: dict = None) -> Optional[str]:
if api_get_version is None: if rpc_get_version is None:
try: try:
api_get_version = await self.api.get_version() rpc_get_version = await self.rpc.get_version()
except APIError: except APIError:
pass pass
if api_get_version is not None: if rpc_get_version is not None:
if "Code" in api_get_version.keys(): if "Code" in rpc_get_version.keys():
if api_get_version["Code"] == 131: if rpc_get_version["Code"] == 131:
try: try:
api_ver = api_get_version["Msg"] rpc_ver = rpc_get_version["Msg"]
if not isinstance(api_ver, str): if not isinstance(rpc_ver, str):
api_ver = api_ver["api_ver"] rpc_ver = rpc_ver["rpc_ver"]
self.api_ver = api_ver.replace("whatsminer v", "") self.rpc_ver = rpc_ver.replace("whatsminer v", "")
except (KeyError, TypeError): except (KeyError, TypeError):
pass pass
else: else:
self.api.api_ver = self.api_ver self.rpc.rpc_ver = self.rpc_ver
return self.api_ver return self.rpc_ver
return self.api_ver return self.rpc_ver
async def _get_fw_ver( async def _get_fw_ver(
self, api_get_version: dict = None, api_summary: dict = None self, rpc_get_version: dict = None, rpc_summary: dict = None
) -> Optional[str]: ) -> Optional[str]:
if api_get_version is None: if rpc_get_version is None:
try: try:
api_get_version = await self.api.get_version() rpc_get_version = await self.rpc.get_version()
except APIError: except APIError:
pass pass
if api_get_version is not None: if rpc_get_version is not None:
if "Code" in api_get_version.keys(): if "Code" in rpc_get_version.keys():
if api_get_version["Code"] == 131: if rpc_get_version["Code"] == 131:
try: try:
self.fw_ver = api_get_version["Msg"]["fw_ver"] self.fw_ver = rpc_get_version["Msg"]["fw_ver"]
except (KeyError, TypeError): except (KeyError, TypeError):
pass pass
else: else:
return self.fw_ver return self.fw_ver
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary: if rpc_summary:
try: try:
self.fw_ver = api_summary["SUMMARY"][0]["Firmware Version"].replace( self.fw_ver = rpc_summary["SUMMARY"][0]["Firmware Version"].replace(
"'", "" "'", ""
) )
except LookupError: except LookupError:
@@ -369,50 +369,50 @@ class BTMiner(BaseMiner):
return self.fw_ver return self.fw_ver
async def _get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]: async def _get_hostname(self, rpc_get_miner_info: dict = None) -> Optional[str]:
hostname = None hostname = None
if api_get_miner_info is None: if rpc_get_miner_info is None:
try: try:
api_get_miner_info = await self.api.get_miner_info() rpc_get_miner_info = await self.rpc.get_miner_info()
except APIError: except APIError:
return None # only one way to get this return None # only one way to get this
if api_get_miner_info is not None: if rpc_get_miner_info is not None:
try: try:
hostname = api_get_miner_info["Msg"]["hostname"] hostname = rpc_get_miner_info["Msg"]["hostname"]
except KeyError: except KeyError:
return None return None
return hostname return hostname
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2) return round(float(rpc_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
except LookupError: except LookupError:
pass pass
async def _get_hashboards(self, api_devs: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_devs: dict = None) -> List[HashBoard]:
hashboards = [ hashboards = [
HashBoard(slot=i, expected_chips=self.expected_chips) HashBoard(slot=i, expected_chips=self.expected_chips)
for i in range(self.expected_hashboards) for i in range(self.expected_hashboards)
] ]
if api_devs is None: if rpc_devs is None:
try: try:
api_devs = await self.api.devs() rpc_devs = await self.rpc.devs()
except APIError: except APIError:
pass pass
if api_devs is not None: if rpc_devs is not None:
try: try:
for board in api_devs["DEVS"]: for board in rpc_devs["DEVS"]:
if len(hashboards) < board["ASC"] + 1: if len(hashboards) < board["ASC"] + 1:
hashboards.append( hashboards.append(
HashBoard( HashBoard(
@@ -433,62 +433,62 @@ class BTMiner(BaseMiner):
return hashboards return hashboards
async def _get_env_temp(self, api_summary: dict = None) -> Optional[float]: async def _get_env_temp(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return api_summary["SUMMARY"][0]["Env Temp"] return rpc_summary["SUMMARY"][0]["Env Temp"]
except LookupError: except LookupError:
pass pass
async def _get_wattage(self, api_summary: dict = None) -> Optional[int]: async def _get_wattage(self, rpc_summary: dict = None) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
wattage = api_summary["SUMMARY"][0]["Power"] wattage = rpc_summary["SUMMARY"][0]["Power"]
return wattage if not wattage == -1 else None return wattage if not wattage == -1 else None
except LookupError: except LookupError:
pass pass
async def _get_wattage_limit(self, api_summary: dict = None) -> Optional[int]: async def _get_wattage_limit(self, rpc_summary: dict = None) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return api_summary["SUMMARY"][0]["Power Limit"] return rpc_summary["SUMMARY"][0]["Power Limit"]
except LookupError: except LookupError:
pass pass
async def _get_fans( async def _get_fans(
self, api_summary: dict = None, api_get_psu: dict = None self, rpc_summary: dict = None, rpc_get_psu: dict = None
) -> List[Fan]: ) -> List[Fan]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
fans = [Fan() for _ in range(self.expected_fans)] fans = [Fan() for _ in range(self.expected_fans)]
if api_summary is not None: if rpc_summary is not None:
try: try:
if self.expected_fans > 0: if self.expected_fans > 0:
fans = [ fans = [
Fan(api_summary["SUMMARY"][0].get("Fan Speed In", 0)), Fan(rpc_summary["SUMMARY"][0].get("Fan Speed In", 0)),
Fan(api_summary["SUMMARY"][0].get("Fan Speed Out", 0)), Fan(rpc_summary["SUMMARY"][0].get("Fan Speed Out", 0)),
] ]
except LookupError: except LookupError:
pass pass
@@ -496,45 +496,45 @@ class BTMiner(BaseMiner):
return fans return fans
async def _get_fan_psu( async def _get_fan_psu(
self, api_summary: dict = None, api_get_psu: dict = None self, rpc_summary: dict = None, rpc_get_psu: dict = None
) -> Optional[int]: ) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return int(api_summary["SUMMARY"][0]["Power Fanspeed"]) return int(rpc_summary["SUMMARY"][0]["Power Fanspeed"])
except LookupError: except LookupError:
pass pass
if api_get_psu is None: if rpc_get_psu is None:
try: try:
api_get_psu = await self.api.get_psu() rpc_get_psu = await self.rpc.get_psu()
except APIError: except APIError:
pass pass
if api_get_psu is not None: if rpc_get_psu is not None:
try: try:
return int(api_get_psu["Msg"]["fan_speed"]) return int(rpc_get_psu["Msg"]["fan_speed"])
except (KeyError, TypeError): except (KeyError, TypeError):
pass pass
async def _get_errors( async def _get_errors(
self, api_summary: dict = None, api_get_error_code: dict = None self, rpc_summary: dict = None, rpc_get_error_code: dict = None
) -> List[MinerErrorData]: ) -> List[MinerErrorData]:
errors = [] errors = []
if api_get_error_code is None and api_summary is None: if rpc_get_error_code is None and rpc_summary is None:
try: try:
api_get_error_code = await self.api.get_error_code() rpc_get_error_code = await self.rpc.get_error_code()
except APIError: except APIError:
pass pass
if api_get_error_code is not None: if rpc_get_error_code is not None:
try: try:
for err in api_get_error_code["Msg"]["error_code"]: for err in rpc_get_error_code["Msg"]["error_code"]:
if isinstance(err, dict): if isinstance(err, dict):
for code in err: for code in err:
errors.append(WhatsminerError(error_code=int(code))) errors.append(WhatsminerError(error_code=int(code)))
@@ -543,48 +543,48 @@ class BTMiner(BaseMiner):
except KeyError: except KeyError:
pass pass
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
for i in range(api_summary["SUMMARY"][0]["Error Code Count"]): for i in range(rpc_summary["SUMMARY"][0]["Error Code Count"]):
err = api_summary["SUMMARY"][0].get(f"Error Code {i}") err = rpc_summary["SUMMARY"][0].get(f"Error Code {i}")
if err: if err:
errors.append(WhatsminerError(error_code=err)) errors.append(WhatsminerError(error_code=err))
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
return errors return errors
async def _get_expected_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
expected_hashrate = api_summary["SUMMARY"][0]["Factory GHS"] expected_hashrate = rpc_summary["SUMMARY"][0]["Factory GHS"]
if expected_hashrate: if expected_hashrate:
return round(expected_hashrate / 1000, 2) return round(expected_hashrate / 1000, 2)
except LookupError: except LookupError:
pass pass
async def _get_fault_light(self, api_get_miner_info: dict = None) -> Optional[bool]: async def _get_fault_light(self, rpc_get_miner_info: dict = None) -> Optional[bool]:
if api_get_miner_info is None: if rpc_get_miner_info is None:
try: try:
api_get_miner_info = await self.api.get_miner_info() rpc_get_miner_info = await self.rpc.get_miner_info()
except APIError: except APIError:
if not self.light: if not self.light:
self.light = False self.light = False
if api_get_miner_info is not None: if rpc_get_miner_info is not None:
try: try:
self.light = not (api_get_miner_info["Msg"]["ledstat"] == "auto") self.light = not (rpc_get_miner_info["Msg"]["ledstat"] == "auto")
except KeyError: except KeyError:
pass pass
@@ -600,46 +600,46 @@ class BTMiner(BaseMiner):
): ):
if not hostname: if not hostname:
hostname = await self.get_hostname() hostname = await self.get_hostname()
await self.api.net_config( await self.rpc.net_config(
ip=ip, mask=subnet_mask, dns=dns, gate=gateway, host=hostname, dhcp=False ip=ip, mask=subnet_mask, dns=dns, gate=gateway, host=hostname, dhcp=False
) )
async def set_dhcp(self, hostname: str = None): async def set_dhcp(self, hostname: str = None):
if hostname: if hostname:
await self.set_hostname(hostname) await self.set_hostname(hostname)
await self.api.net_config() await self.rpc.net_config()
async def set_hostname(self, hostname: str): async def set_hostname(self, hostname: str):
await self.api.set_hostname(hostname) await self.rpc.set_hostname(hostname)
async def _is_mining(self, api_status: dict = None) -> Optional[bool]: async def _is_mining(self, rpc_status: dict = None) -> Optional[bool]:
if api_status is None: if rpc_status is None:
try: try:
api_status = await self.api.status() rpc_status = await self.rpc.status()
except APIError: except APIError:
pass pass
if api_status is not None: if rpc_status is not None:
try: try:
if api_status["Msg"].get("btmineroff"): if rpc_status["Msg"].get("btmineroff"):
try: try:
await self.api.devdetails() await self.rpc.devdetails()
except APIError: except APIError:
return False return False
return True return True
return True if api_status["Msg"]["mineroff"] == "false" else False return True if rpc_status["Msg"]["mineroff"] == "false" else False
except LookupError: except LookupError:
pass pass
async def _get_uptime(self, api_summary: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_summary: dict = None) -> Optional[int]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return int(api_summary["SUMMARY"][0]["Elapsed"]) return int(rpc_summary["SUMMARY"][0]["Elapsed"])
except LookupError: except LookupError:
pass pass

64
pyasic/miners/backends/cgminer.py
View File

@@ -26,31 +26,31 @@ CGMINER_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -59,79 +59,79 @@ CGMINER_DATA_LOC = DataLocations(
class CGMiner(BaseMiner): class CGMiner(BaseMiner):
"""Base handler for CGMiner based miners""" """Base handler for CGMiner based miners"""
_api_cls = CGMinerRPCAPI _rpc_cls = CGMinerRPCAPI
api: CGMinerRPCAPI rpc: CGMinerRPCAPI
data_locations = CGMINER_DATA_LOC data_locations = CGMINER_DATA_LOC
async def get_config(self) -> MinerConfig: async def get_config(self) -> MinerConfig:
# get pool data # get pool data
try: try:
pools = await self.api.pools() pools = await self.rpc.pools()
except APIError: except APIError:
return self.config return self.config
self.config = MinerConfig.from_api(pools) self.config = MinerConfig.from_rpc(pools)
return self.config return self.config
################################################## ##################################################
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]: async def _get_api_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
self.api_ver = api_version["VERSION"][0]["API"] self.rpc_ver = rpc_version["VERSION"][0]["API"]
except LookupError: except LookupError:
pass pass
return self.api_ver return self.rpc_ver
async def _get_fw_ver(self, api_version: dict = None) -> Optional[str]: async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
if api_version is None: if rpc_version is None:
try: try:
api_version = await self.api.version() rpc_version = await self.rpc.version()
except APIError: except APIError:
pass pass
if api_version is not None: if rpc_version is not None:
try: try:
self.fw_ver = api_version["VERSION"][0]["CGMiner"] self.fw_ver = rpc_version["VERSION"][0]["CGMiner"]
except LookupError: except LookupError:
pass pass
return self.fw_ver return self.fw_ver
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round( return round(
float(float(api_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2 float(float(rpc_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2
) )
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_stats: dict = None) -> Optional[int]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
return int(api_stats["STATS"][1]["Elapsed"]) return int(rpc_stats["STATS"][1]["Elapsed"])
except LookupError: except LookupError:
pass pass

38
pyasic/miners/backends/goldshell.py
View File

@@ -37,7 +37,7 @@ GOLDSHELL_DATA_LOC = DataLocations(
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
@@ -45,22 +45,22 @@ GOLDSHELL_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[ [
RPCAPICommand("api_devs", "devs"), RPCAPICommand("rpc_devs", "devs"),
RPCAPICommand("api_devdetails", "devdetails"), RPCAPICommand("rpc_devdetails", "devdetails"),
], ],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -130,11 +130,11 @@ class GoldshellMiner(BFGMiner):
pass pass
async def _get_hashboards( async def _get_hashboards(
self, api_devs: dict = None, api_devdetails: dict = None self, rpc_devs: dict = None, rpc_devdetails: dict = None
) -> List[HashBoard]: ) -> List[HashBoard]:
if api_devs is None: if rpc_devs is None:
try: try:
api_devs = await self.api.devs() rpc_devs = await self.rpc.devs()
except APIError: except APIError:
pass pass
@@ -143,9 +143,9 @@ class GoldshellMiner(BFGMiner):
for i in range(self.expected_hashboards) for i in range(self.expected_hashboards)
] ]
if api_devs is not None: if rpc_devs is not None:
if api_devs.get("DEVS"): if rpc_devs.get("DEVS"):
for board in api_devs["DEVS"]: for board in rpc_devs["DEVS"]:
if board.get("ID") is not None: if board.get("ID") is not None:
try: try:
b_id = board["ID"] b_id = board["ID"]
@@ -157,17 +157,17 @@ class GoldshellMiner(BFGMiner):
except KeyError: except KeyError:
pass pass
else: else:
logger.error(self, api_devs) logger.error(self, rpc_devs)
if api_devdetails is None: if rpc_devdetails is None:
try: try:
api_devdetails = await self.api.devdetails() rpc_devdetails = await self.rpc.devdetails()
except APIError: except APIError:
pass pass
if api_devdetails is not None: if rpc_devdetails is not None:
if api_devdetails.get("DEVS"): if rpc_devdetails.get("DEVS"):
for board in api_devdetails["DEVS"]: for board in rpc_devdetails["DEVS"]:
if board.get("ID") is not None: if board.get("ID") is not None:
try: try:
b_id = board["ID"] b_id = board["ID"]
@@ -175,6 +175,6 @@ class GoldshellMiner(BFGMiner):
except KeyError: except KeyError:
pass pass
else: else:
logger.error(self, api_devdetails) logger.error(self, rpc_devdetails)
return hashboards return hashboards

46
pyasic/miners/backends/innosilicon.py
View File

@@ -41,23 +41,23 @@ INNOSILICON_DATA_LOC = DataLocations(
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[ [
RPCAPICommand("api_summary", "summary"), RPCAPICommand("rpc_summary", "summary"),
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
], ],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[ [
RPCAPICommand("api_stats", "stats"), RPCAPICommand("rpc_stats", "stats"),
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
], ],
), ),
@@ -65,7 +65,7 @@ INNOSILICON_DATA_LOC = DataLocations(
"_get_wattage", "_get_wattage",
[ [
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
RPCAPICommand("api_stats", "stats"), RPCAPICommand("rpc_stats", "stats"),
], ],
), ),
str(DataOptions.WATTAGE_LIMIT): DataFunction( str(DataOptions.WATTAGE_LIMIT): DataFunction(
@@ -88,7 +88,7 @@ INNOSILICON_DATA_LOC = DataLocations(
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -168,14 +168,14 @@ class Innosilicon(CGMiner):
pass pass
async def _get_hashrate( async def _get_hashrate(
self, api_summary: dict = None, web_get_all: dict = None self, rpc_summary: dict = None, web_get_all: dict = None
) -> Optional[float]: ) -> Optional[float]:
if web_get_all: if web_get_all:
web_get_all = web_get_all["all"] web_get_all = web_get_all["all"]
if api_summary is None and web_get_all is None: if rpc_summary is None and web_get_all is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
@@ -193,14 +193,14 @@ class Innosilicon(CGMiner):
except KeyError: except KeyError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2) return round(float(rpc_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
except (KeyError, IndexError): except (KeyError, IndexError):
pass pass
async def _get_hashboards( async def _get_hashboards(
self, api_stats: dict = None, web_get_all: dict = None self, rpc_stats: dict = None, web_get_all: dict = None
) -> List[HashBoard]: ) -> List[HashBoard]:
if web_get_all: if web_get_all:
web_get_all = web_get_all["all"] web_get_all = web_get_all["all"]
@@ -210,9 +210,9 @@ class Innosilicon(CGMiner):
for i in range(self.expected_hashboards) for i in range(self.expected_hashboards)
] ]
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
@@ -224,9 +224,9 @@ class Innosilicon(CGMiner):
else: else:
web_get_all = web_get_all["all"] web_get_all = web_get_all["all"]
if api_stats is not None: if rpc_stats is not None:
if api_stats.get("STATS"): if rpc_stats.get("STATS"):
for board in api_stats["STATS"]: for board in rpc_stats["STATS"]:
try: try:
idx = board["Chain ID"] idx = board["Chain ID"]
chips = board["Num active chips"] chips = board["Num active chips"]
@@ -258,7 +258,7 @@ class Innosilicon(CGMiner):
return hashboards return hashboards
async def _get_wattage( async def _get_wattage(
self, web_get_all: dict = None, api_stats: dict = None self, web_get_all: dict = None, rpc_stats: dict = None
) -> Optional[int]: ) -> Optional[int]:
if web_get_all: if web_get_all:
web_get_all = web_get_all["all"] web_get_all = web_get_all["all"]
@@ -277,15 +277,15 @@ class Innosilicon(CGMiner):
except KeyError: except KeyError:
pass pass
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
if api_stats.get("STATS"): if rpc_stats.get("STATS"):
for board in api_stats["STATS"]: for board in rpc_stats["STATS"]:
try: try:
wattage = board["power"] wattage = board["power"]
except KeyError: except KeyError:

106
pyasic/miners/backends/luxminer.py
View File

@@ -26,30 +26,30 @@ LUXMINER_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.MAC): DataFunction( str(DataOptions.MAC): DataFunction(
"_get_mac", "_get_mac",
[RPCAPICommand("api_config", "config")], [RPCAPICommand("rpc_config", "config")],
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", "_get_wattage",
[RPCAPICommand("api_power", "power")], [RPCAPICommand("rpc_power", "power")],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_fans", "fans")], [RPCAPICommand("rpc_fans", "fans")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", [RPCAPICommand("api_stats", "stats")] "_get_uptime", [RPCAPICommand("rpc_stats", "stats")]
), ),
} }
) )
@@ -58,8 +58,8 @@ LUXMINER_DATA_LOC = DataLocations(
class LUXMiner(BaseMiner): class LUXMiner(BaseMiner):
"""Handler for LuxOS miners""" """Handler for LuxOS miners"""
_api_cls = LUXMinerRPCAPI _rpc_cls = LUXMinerRPCAPI
api: LUXMinerRPCAPI rpc: LUXMinerRPCAPI
firmware = "LuxOS" firmware = "LuxOS"
@@ -67,14 +67,14 @@ class LUXMiner(BaseMiner):
async def _get_session(self) -> Optional[str]: async def _get_session(self) -> Optional[str]:
try: try:
data = await self.api.session() data = await self.rpc.session()
if not data["SESSION"][0]["SessionID"] == "": if not data["SESSION"][0]["SessionID"] == "":
return data["SESSION"][0]["SessionID"] return data["SESSION"][0]["SessionID"]
except APIError: except APIError:
pass pass
try: try:
data = await self.api.logon() data = await self.rpc.logon()
return data["SESSION"][0]["SessionID"] return data["SESSION"][0]["SessionID"]
except (LookupError, APIError): except (LookupError, APIError):
return return
@@ -83,7 +83,7 @@ class LUXMiner(BaseMiner):
try: try:
session_id = await self._get_session() session_id = await self._get_session()
if session_id: if session_id:
await self.api.ledset(session_id, "red", "blink") await self.rpc.ledset(session_id, "red", "blink")
return True return True
except (APIError, LookupError): except (APIError, LookupError):
pass pass
@@ -93,7 +93,7 @@ class LUXMiner(BaseMiner):
try: try:
session_id = await self._get_session() session_id = await self._get_session()
if session_id: if session_id:
await self.api.ledset(session_id, "red", "off") await self.rpc.ledset(session_id, "red", "off")
return True return True
except (APIError, LookupError): except (APIError, LookupError):
pass pass
@@ -106,7 +106,7 @@ class LUXMiner(BaseMiner):
try: try:
session_id = await self._get_session() session_id = await self._get_session()
if session_id: if session_id:
await self.api.resetminer(session_id) await self.rpc.resetminer(session_id)
return True return True
except (APIError, LookupError): except (APIError, LookupError):
pass pass
@@ -116,7 +116,7 @@ class LUXMiner(BaseMiner):
try: try:
session_id = await self._get_session() session_id = await self._get_session()
if session_id: if session_id:
await self.api.curtail(session_id) await self.rpc.curtail(session_id)
return True return True
except (APIError, LookupError): except (APIError, LookupError):
pass pass
@@ -126,7 +126,7 @@ class LUXMiner(BaseMiner):
try: try:
session_id = await self._get_session() session_id = await self._get_session()
if session_id: if session_id:
await self.api.wakeup(session_id) await self.rpc.wakeup(session_id)
return True return True
except (APIError, LookupError): except (APIError, LookupError):
pass pass
@@ -135,7 +135,7 @@ class LUXMiner(BaseMiner):
try: try:
session_id = await self._get_session() session_id = await self._get_session()
if session_id: if session_id:
await self.api.rebootdevice(session_id) await self.rpc.rebootdevice(session_id)
return True return True
except (APIError, LookupError): except (APIError, LookupError):
pass pass
@@ -148,48 +148,48 @@ class LUXMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_mac(self, api_config: dict = None) -> Optional[str]: async def _get_mac(self, rpc_config: dict = None) -> Optional[str]:
mac = None mac = None
if api_config is None: if rpc_config is None:
try: try:
api_config = await self.api.config() rpc_config = await self.rpc.config()
except APIError: except APIError:
return None return None
if api_config is not None: if rpc_config is not None:
try: try:
mac = api_config["CONFIG"][0]["MACAddr"] mac = rpc_config["CONFIG"][0]["MACAddr"]
except KeyError: except KeyError:
return None return None
return mac return mac
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round(float(api_summary["SUMMARY"][0]["GHS 5s"] / 1000), 2) return round(float(rpc_summary["SUMMARY"][0]["GHS 5s"] / 1000), 2)
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
hashboards = [] hashboards = []
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
board_offset = -1 board_offset = -1
boards = api_stats["STATS"] boards = rpc_stats["STATS"]
if len(boards) > 1: if len(boards) > 1:
for board_num in range(1, 16, 5): for board_num in range(1, 16, 5):
for _b_num in range(5): for _b_num in range(5):
@@ -231,48 +231,48 @@ class LUXMiner(BaseMiner):
return hashboards return hashboards
async def _get_wattage(self, api_power: dict = None) -> Optional[int]: async def _get_wattage(self, rpc_power: dict = None) -> Optional[int]:
if api_power is None: if rpc_power is None:
try: try:
api_power = await self.api.power() rpc_power = await self.rpc.power()
except APIError: except APIError:
pass pass
if api_power is not None: if rpc_power is not None:
try: try:
return api_power["POWER"][0]["Watts"] return rpc_power["POWER"][0]["Watts"]
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass
async def _get_fans(self, api_fans: dict = None) -> List[Fan]: async def _get_fans(self, rpc_fans: dict = None) -> List[Fan]:
if api_fans is None: if rpc_fans is None:
try: try:
api_fans = await self.api.fans() rpc_fans = await self.rpc.fans()
except APIError: except APIError:
pass pass
fans = [] fans = []
if api_fans is not None: if rpc_fans is not None:
for fan in range(self.expected_fans): for fan in range(self.expected_fans):
try: try:
fans.append(Fan(api_fans["FANS"][fan]["RPM"])) fans.append(Fan(rpc_fans["FANS"][fan]["RPM"]))
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
fans.append(Fan()) fans.append(Fan())
return fans return fans
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: async def _get_expected_hashrate(self, rpc_stats: dict = None) -> Optional[float]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
expected_rate = api_stats["STATS"][1]["total_rateideal"] expected_rate = rpc_stats["STATS"][1]["total_rateideal"]
try: try:
rate_unit = api_stats["STATS"][1]["rate_unit"] rate_unit = rpc_stats["STATS"][1]["rate_unit"]
except KeyError: except KeyError:
rate_unit = "GH" rate_unit = "GH"
if rate_unit == "GH": if rate_unit == "GH":
@@ -284,15 +284,15 @@ class LUXMiner(BaseMiner):
except LookupError: except LookupError:
pass pass
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]: async def _get_uptime(self, rpc_stats: dict = None) -> Optional[int]:
if api_stats is None: if rpc_stats is None:
try: try:
api_stats = await self.api.stats() rpc_stats = await self.rpc.stats()
except APIError: except APIError:
pass pass
if api_stats is not None: if rpc_stats is not None:
try: try:
return int(api_stats["STATS"][1]["Elapsed"]) return int(rpc_stats["STATS"][1]["Elapsed"])
except LookupError: except LookupError:
pass pass

2
pyasic/miners/backends/unknown.py
View File

@@ -30,7 +30,7 @@ class UnknownMiner(BaseMiner):
) -> None: ) -> None:
super().__init__(ip) super().__init__(ip)
self.ip = ip self.ip = ip
self.api = UnknownRPCAPI(ip) self.rpc = UnknownRPCAPI(ip)
def __repr__(self) -> str: def __repr__(self) -> str:
return f"Unknown: {str(self.ip)}" return f"Unknown: {str(self.ip)}"

22
pyasic/miners/backends/vnish.py
View File

@@ -36,7 +36,7 @@ VNISH_DATA_LOC = DataLocations(
), ),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", "_get_api_ver",
[RPCAPICommand("api_version", "version")], [RPCAPICommand("rpc_version", "version")],
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", "_get_fw_ver",
@@ -48,15 +48,15 @@ VNISH_DATA_LOC = DataLocations(
), ),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "_get_hashrate",
[RPCAPICommand("api_summary", "summary")], [RPCAPICommand("rpc_summary", "summary")],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "_get_expected_hashrate",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "_get_hashboards",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", "_get_wattage",
@@ -68,11 +68,11 @@ VNISH_DATA_LOC = DataLocations(
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "_get_fans",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", "_get_uptime",
[RPCAPICommand("api_stats", "stats")], [RPCAPICommand("rpc_stats", "stats")],
), ),
} }
) )
@@ -172,18 +172,18 @@ class VNish(BMMiner):
except KeyError: except KeyError:
pass pass
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]: async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[float]:
# get hr from API # get hr from API
if api_summary is None: if rpc_summary is None:
try: try:
api_summary = await self.api.summary() rpc_summary = await self.rpc.summary()
except APIError: except APIError:
pass pass
if api_summary is not None: if rpc_summary is not None:
try: try:
return round( return round(
float(float(api_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2 float(float(rpc_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2
) )
except (LookupError, ValueError, TypeError): except (LookupError, ValueError, TypeError):
pass pass

13
pyasic/miners/base.py
View File

@@ -24,15 +24,16 @@ from pyasic.data.error_codes import MinerErrorData
from pyasic.errors import APIError from pyasic.errors import APIError
from pyasic.logger import logger from pyasic.logger import logger
from pyasic.miners.data import DataLocations, DataOptions, RPCAPICommand, WebAPICommand from pyasic.miners.data import DataLocations, DataOptions, RPCAPICommand, WebAPICommand
from pyasic.rpc.base import BaseMinerRPCAPI
class MinerProtocol(Protocol): class MinerProtocol(Protocol):
_api_cls: Type = None _rpc_cls: Type = None
_web_cls: Type = None _web_cls: Type = None
_ssh_cls: Type = None _ssh_cls: Type = None
ip: str = None ip: str = None
api: _api_cls = None rpc: _rpc_cls = None
web: _web_cls = None web: _web_cls = None
ssh: _ssh_cls = None ssh: _ssh_cls = None
@@ -73,6 +74,10 @@ class MinerProtocol(Protocol):
model_data.append(f"({self.firmware})") model_data.append(f"({self.firmware})")
return " ".join(model_data) return " ".join(model_data)
@property
def api(self):
return self.rpc
async def check_light(self) -> bool: async def check_light(self) -> bool:
return await self.get_fault_light() return await self.get_fault_light()
@@ -488,8 +493,8 @@ class BaseMiner(MinerProtocol):
) )
# interfaces # interfaces
if self._api_cls is not None: if self._rpc_cls is not None:
self.api = self._api_cls(ip) self.rpc = self._rpc_cls(ip)
if self._web_cls is not None: if self._web_cls is not None:
self.web = self._web_cls(ip) self.web = self._web_cls(ip)
if self._ssh_cls is not None: if self._ssh_cls is not None: