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

bug: add test to cross check function arguments, and fix some method implementations and naming.

Browse Source
This commit is contained in:
UpstreamData
2024-01-15 10:16:47 -07:00
parent 269e6aac14
commit 672e753afb
6 changed files with 106 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -30,7 +30,7 @@ class HiveonT9(Hiveon, T9):
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_mac(self): async def get_mac(self):
try: try:
mac = ( mac = (
(await self.send_ssh_command("cat /sys/class/net/eth0/address")) (await self.send_ssh_command("cat /sys/class/net/eth0/address"))
@@ -41,7 +41,7 @@ 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, api_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)
@@ -69,21 +69,21 @@ class HiveonT9(Hiveon, T9):
hashboards[board].chip_temp = api_stats["STATS"][1][ hashboards[board].chip_temp = api_stats["STATS"][1][
f"temp2_{chipset}" f"temp2_{chipset}"
] ]
except LookupError: except (KeyError, IndexError):
pass pass
else: else:
hashboards[board].missing = False hashboards[board].missing = False
try: try:
hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"] hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"]
chips += api_stats["STATS"][1][f"chain_acn{chipset}"] chips += api_stats["STATS"][1][f"chain_acn{chipset}"]
except LookupError: except (KeyError, IndexError):
pass pass
hashboards[board].hashrate = round(hashrate / 1000, 2) hashboards[board].hashrate = round(hashrate / 1000, 2)
hashboards[board].chips = chips hashboards[board].chips = chips
return hashboards return hashboards
async def _get_wattage(self, api_stats: dict = None) -> Optional[int]: async def get_wattage(self, api_stats: dict = None) -> Optional[int]:
if not api_stats: if not api_stats:
try: try:
api_stats = await self.api.stats() api_stats = await self.api.stats()
@@ -94,13 +94,13 @@ class HiveonT9(Hiveon, T9):
boards = api_stats.get("STATS") boards = api_stats.get("STATS")
try: try:
wattage_raw = boards[1]["chain_power"] wattage_raw = boards[1]["chain_power"]
except LookupError: except (KeyError, IndexError):
pass pass
else: else:
# 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, api_stats: dict = None) -> Optional[float]:
env_temp_list = [] env_temp_list = []
board_map = { board_map = {
0: [2, 9, 10], 0: [2, 9, 10],
@@ -119,7 +119,7 @@ class HiveonT9(Hiveon, T9):
env_temp = api_stats["STATS"][1][f"temp3_{chipset}"] env_temp = api_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 LookupError: except (KeyError, IndexError):
pass pass
if not env_temp_list == []: if not env_temp_list == []:

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

@@ -557,7 +557,6 @@ class BTMiner(BaseMiner):
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): async def _get_expected_hashrate(self, api_summary: dict = None):

78
pyasic/miners/backends/cgminer_avalon.py
View File

@@ -14,6 +14,7 @@
# limitations under the License. - # limitations under the License. -
# ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------
import logging
import re import re
from typing import List, Optional from typing import List, Optional
@@ -27,41 +28,42 @@ from pyasic.miners.base import DataFunction, DataLocations, DataOptions, RPCAPIC
AVALON_DATA_LOC = DataLocations( AVALON_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.MAC): DataFunction( str(DataOptions.MAC): DataFunction(
"_get_mac", [RPCAPICommand("api_version", "version")] "get_mac", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", [RPCAPICommand("api_version", "version")] "get_api_ver", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", [RPCAPICommand("api_version", "version")] "get_fw_ver", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"), str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", [RPCAPICommand("api_devs", "devs")] "get_hashrate", [RPCAPICommand("api_devs", "devs")]
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")] "get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", [RPCAPICommand("api_stats", "stats")] "get_hashboards", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction( str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
"_get_env_temp", [RPCAPICommand("api_stats", "stats")] "get_env_temp", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"), str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction( str(DataOptions.WATTAGE_LIMIT): DataFunction(
"_get_wattage_limit", [RPCAPICommand("api_stats", "stats")] "get_wattage_limit", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", [RPCAPICommand("api_stats", "stats")] "get_fans", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"), str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"), str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction( str(DataOptions.FAULT_LIGHT): DataFunction(
"_get_fault_light", [RPCAPICommand("api_stats", "stats")] "get_fault_light", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.IS_MINING): DataFunction("_is_mining"), str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.UPTIME): DataFunction("_get_uptime"), str(DataOptions.UPTIME): DataFunction("get_uptime"),
str(DataOptions.CONFIG): DataFunction("get_config"), str(DataOptions.CONFIG): DataFunction("get_config"),
} }
) )
@@ -172,7 +174,7 @@ class CGMinerAvalon(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, api_version: dict = None) -> Optional[str]:
if not api_version: if not api_version:
try: try:
api_version = await self.api.version() api_version = await self.api.version()
@@ -190,7 +192,7 @@ class CGMinerAvalon(CGMiner):
except (KeyError, ValueError): except (KeyError, ValueError):
pass pass
async def _get_hostname(self) -> Optional[str]: async def get_hostname(self) -> Optional[str]:
return None return None
# if not mac: # if not mac:
# mac = await self.get_mac() # mac = await self.get_mac()
@@ -198,7 +200,7 @@ class CGMinerAvalon(CGMiner):
# if mac: # if mac:
# return f"Avalon{mac.replace(':', '')[-6:]}" # return f"Avalon{mac.replace(':', '')[-6:]}"
async def _get_hashrate(self, api_devs: dict = None) -> Optional[float]: async def get_hashrate(self, api_devs: dict = None) -> Optional[float]:
if not api_devs: if not api_devs:
try: try:
api_devs = await self.api.devs() api_devs = await self.api.devs()
@@ -208,10 +210,10 @@ class CGMinerAvalon(CGMiner):
if api_devs: if api_devs:
try: try:
return round(float(api_devs["DEVS"][0]["MHS 1m"] / 1000000), 2) return round(float(api_devs["DEVS"][0]["MHS 1m"] / 1000000), 2)
except (LookupError, 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, api_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)
@@ -227,7 +229,7 @@ class CGMinerAvalon(CGMiner):
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = api_stats["STATS"][0]["MM ID0"]
parsed_stats = self.parse_stats(unparsed_stats) parsed_stats = self.parse_stats(unparsed_stats)
except (LookupError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
return hashboards return hashboards
for board in range(self.expected_hashboards): for board in range(self.expected_hashboards):
@@ -259,7 +261,7 @@ class CGMinerAvalon(CGMiner):
return hashboards return hashboards
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]: async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
if not api_stats: if not api_stats:
try: try:
api_stats = await self.api.stats() api_stats = await self.api.stats()
@@ -271,10 +273,10 @@ class CGMinerAvalon(CGMiner):
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = api_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 (LookupError, 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, api_stats: dict = None) -> Optional[float]:
if not api_stats: if not api_stats:
try: try:
api_stats = await self.api.stats() api_stats = await self.api.stats()
@@ -286,13 +288,13 @@ class CGMinerAvalon(CGMiner):
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = api_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 (LookupError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
async def _get_wattage(self) -> Optional[int]: async def get_wattage(self) -> Optional[int]:
return None return None
async def _get_wattage_limit(self, api_stats: dict = None) -> Optional[int]: async def get_wattage_limit(self, api_stats: dict = None) -> Optional[int]:
if not api_stats: if not api_stats:
try: try:
api_stats = await self.api.stats() api_stats = await self.api.stats()
@@ -304,17 +306,17 @@ class CGMinerAvalon(CGMiner):
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = api_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 (LookupError, 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, api_stats: dict = None) -> List[Fan]:
if not api_stats: if not api_stats:
try: try:
api_stats = await self.api.stats() api_stats = await self.api.stats()
except APIError: except APIError:
pass pass
fans_data = [Fan() for _ in range(self.expected_fans)] fans_data = [Fan() for _ in range(self.fan_count)]
if api_stats: if api_stats:
try: try:
unparsed_stats = api_stats["STATS"][0]["MM ID0"] unparsed_stats = api_stats["STATS"][0]["MM ID0"]
@@ -322,17 +324,17 @@ class CGMinerAvalon(CGMiner):
except LookupError: except LookupError:
return fans_data return fans_data
for fan in range(self.expected_fans): for fan in range(self.fan_count):
try: try:
fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"]) fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"])
except (LookupError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
return fans_data return fans_data
async def _get_errors(self) -> List[MinerErrorData]: async def get_errors(self) -> List[MinerErrorData]:
return [] return []
async def _get_fault_light(self, api_stats: dict = None) -> bool: # noqa async def get_fault_light(self, api_stats: dict = None) -> bool: # noqa
if self.light: if self.light:
return self.light return self.light
if not api_stats: if not api_stats:
@@ -347,7 +349,7 @@ class CGMinerAvalon(CGMiner):
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
except (LookupError, ValueError, TypeError): except (IndexError, KeyError, ValueError, TypeError):
pass pass
try: try:
@@ -361,8 +363,8 @@ class CGMinerAvalon(CGMiner):
pass pass
return False return False
async def _is_mining(self, *args, **kwargs) -> Optional[bool]: async def is_mining(self, *args, **kwargs) -> Optional[bool]:
return None return None
async def _get_uptime(self) -> Optional[int]: async def get_uptime(self) -> Optional[int]:
return None return None

45
pyasic/miners/backends/hiveon.py
View File

@@ -22,39 +22,40 @@ from pyasic.miners.base import DataFunction, DataLocations, DataOptions, RPCAPIC
HIVEON_DATA_LOC = DataLocations( HIVEON_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.MAC): DataFunction("_get_mac"), str(DataOptions.MAC): DataFunction("get_mac"),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", [RPCAPICommand("api_version", "version")] "get_api_ver", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", [RPCAPICommand("api_version", "version")] "get_fw_ver", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"), str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", [RPCAPICommand("api_summary", "summary")] "get_hashrate", [RPCAPICommand("api_summary", "summary")]
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")] "get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", [RPCAPICommand("api_stats", "stats")] "get_hashboards", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction( str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
"_get_env_temp", [RPCAPICommand("api_stats", "stats")] "get_env_temp", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", [RPCAPICommand("api_stats", "stats")] "get_wattage", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"), str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", [RPCAPICommand("api_stats", "stats")] "get_fans", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"), str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"), str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"), str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"), str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", [RPCAPICommand("api_stats", "stats")] "get_uptime", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.CONFIG): DataFunction("get_config"), str(DataOptions.CONFIG): DataFunction("get_config"),
} }
@@ -67,15 +68,19 @@ class Hiveon(BMMiner):
self.pwd = "admin" self.pwd = "admin"
# static data # static data
self.api_type = "Hiveon" self.api_type = "Hiveon"
self.fw_str = "Hive"
# data gathering locations # data gathering locations
self.data_locations = HIVEON_DATA_LOC self.data_locations = HIVEON_DATA_LOC
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]: async def get_model(self) -> Optional[str]:
if self.model is not None:
return self.model + " (Hiveon)"
return "? (Hiveon)"
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
pass pass
async def _get_wattage(self, api_stats: dict = None) -> Optional[int]: async def get_wattage(self, api_stats: dict = None) -> Optional[int]:
pass pass
async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]: async def get_env_temp(self, api_stats: dict = None) -> Optional[float]:
pass pass

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

@@ -33,67 +33,68 @@ from pyasic.web.innosilicon import InnosiliconWebAPI
INNOSILICON_DATA_LOC = DataLocations( INNOSILICON_DATA_LOC = DataLocations(
**{ **{
str(DataOptions.MAC): DataFunction( str(DataOptions.MAC): DataFunction(
"_get_mac", "get_mac",
[ [
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
WebAPICommand("web_overview", "overview"), WebAPICommand("web_overview", "overview"),
], ],
), ),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction( str(DataOptions.API_VERSION): DataFunction(
"_get_api_ver", [RPCAPICommand("api_version", "version")] "get_api_ver", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.FW_VERSION): DataFunction( str(DataOptions.FW_VERSION): DataFunction(
"_get_fw_ver", [RPCAPICommand("api_version", "version")] "get_fw_ver", [RPCAPICommand("api_version", "version")]
), ),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"), str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HASHRATE): DataFunction( str(DataOptions.HASHRATE): DataFunction(
"_get_hashrate", "get_hashrate",
[ [
RPCAPICommand("api_summary", "summary"), RPCAPICommand("api_summary", "summary"),
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
], ],
), ),
str(DataOptions.EXPECTED_HASHRATE): DataFunction( str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"_get_expected_hashrate", "get_expected_hashrate",
), ),
str(DataOptions.HASHBOARDS): DataFunction( str(DataOptions.HASHBOARDS): DataFunction(
"_get_hashboards", "get_hashboards",
[ [
RPCAPICommand("api_stats", "stats"), RPCAPICommand("api_stats", "stats"),
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
], ],
), ),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"), str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction( str(DataOptions.WATTAGE): DataFunction(
"_get_wattage", "get_wattage",
[ [
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
RPCAPICommand("api_stats", "stats"), RPCAPICommand("api_stats", "stats"),
], ],
), ),
str(DataOptions.WATTAGE_LIMIT): DataFunction( str(DataOptions.WATTAGE_LIMIT): DataFunction(
"_get_wattage_limit", "get_wattage_limit",
[ [
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
], ],
), ),
str(DataOptions.FANS): DataFunction( str(DataOptions.FANS): DataFunction(
"_get_fans", "get_fans",
[ [
WebAPICommand("web_get_all", "getAll"), WebAPICommand("web_get_all", "getAll"),
], ],
), ),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"), str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction( str(DataOptions.ERRORS): DataFunction(
"_get_errors", "get_errors",
[ [
WebAPICommand("web_get_error_detail", "getErrorDetail"), WebAPICommand("web_get_error_detail", "getErrorDetail"),
], ],
), ),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"), str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"), str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.UPTIME): DataFunction( str(DataOptions.UPTIME): DataFunction(
"_get_uptime", [RPCAPICommand("api_stats", "stats")] "get_uptime", [RPCAPICommand("api_stats", "stats")]
), ),
str(DataOptions.CONFIG): DataFunction("get_config"), str(DataOptions.CONFIG): DataFunction("get_config"),
} }
@@ -175,7 +176,7 @@ class Innosilicon(CGMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ### ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
################################################## ##################################################
async def _get_mac( async def get_mac(
self, web_get_all: dict = None, web_overview: dict = None self, web_get_all: dict = None, web_overview: dict = None
) -> Optional[str]: ) -> Optional[str]:
if web_get_all: if web_get_all:
@@ -201,7 +202,7 @@ class Innosilicon(CGMiner):
except KeyError: except KeyError:
pass pass
async def _get_hashrate( async def get_hashrate(
self, api_summary: dict = None, web_get_all: dict = None self, api_summary: dict = None, web_get_all: dict = None
) -> Optional[float]: ) -> Optional[float]:
if web_get_all: if web_get_all:
@@ -233,7 +234,7 @@ class Innosilicon(CGMiner):
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, api_stats: dict = None, web_get_all: dict = None
) -> List[HashBoard]: ) -> List[HashBoard]:
if web_get_all: if web_get_all:
@@ -291,7 +292,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, api_stats: dict = None
) -> Optional[int]: ) -> Optional[int]:
if web_get_all: if web_get_all:
@@ -328,7 +329,7 @@ class Innosilicon(CGMiner):
wattage = int(wattage) wattage = int(wattage)
return wattage return wattage
async def _get_fans(self, web_get_all: dict = None) -> List[Fan]: async def get_fans(self, web_get_all: dict = None) -> List[Fan]:
if web_get_all: if web_get_all:
web_get_all = web_get_all["all"] web_get_all = web_get_all["all"]
@@ -353,7 +354,7 @@ class Innosilicon(CGMiner):
return fans return fans
async def _get_errors( async def get_errors(
self, web_get_error_detail: dict = None self, web_get_error_detail: dict = None
) -> List[MinerErrorData]: ) -> List[MinerErrorData]:
errors = [] errors = []
@@ -376,7 +377,7 @@ class Innosilicon(CGMiner):
errors.append(InnosiliconError(error_code=err)) errors.append(InnosiliconError(error_code=err))
return errors return errors
async def _get_wattage_limit(self, web_get_all: dict = None) -> Optional[int]: async def get_wattage_limit(self, web_get_all: dict = None) -> Optional[int]:
if web_get_all: if web_get_all:
web_get_all = web_get_all["all"] web_get_all = web_get_all["all"]
@@ -399,5 +400,5 @@ class Innosilicon(CGMiner):
limit = 1250 + (250 * level) limit = 1250 + (250 * level)
return limit return limit
async def _get_expected_hashrate(self) -> Optional[float]: async def get_expected_hashrate(self) -> Optional[float]:
pass pass

28
tests/miners_tests/__init__.py
View File

@@ -13,13 +13,16 @@
# See the License for the specific language governing permissions and - # See the License for the specific language governing permissions and -
# limitations under the License. - # limitations under the License. -
# ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------
import asyncio
import inspect import inspect
import sys
import unittest import unittest
import warnings import warnings
from dataclasses import asdict from dataclasses import asdict
from pyasic.miners.backends import CGMiner # noqa from pyasic.miners.backends import CGMiner # noqa
from pyasic.miners.miner_factory import MINER_CLASSES from pyasic.miners.base import BaseMiner
from pyasic.miners.miner_factory import MINER_CLASSES, MinerFactory
class MinersTest(unittest.TestCase): class MinersTest(unittest.TestCase):
@@ -28,7 +31,7 @@ class MinersTest(unittest.TestCase):
for miner_model in MINER_CLASSES.keys(): for miner_model in MINER_CLASSES.keys():
for miner_api in MINER_CLASSES[miner_model].keys(): for miner_api in MINER_CLASSES[miner_model].keys():
with self.subTest( with self.subTest(
msg=f"Test creation of miner", msg=f"Creation of miner using model={miner_model}, api={miner_api}",
miner_model=miner_model, miner_model=miner_model,
miner_api=miner_api, miner_api=miner_api,
): ):
@@ -53,6 +56,7 @@ class MinersTest(unittest.TestCase):
"hostname", "hostname",
"is_mining", "is_mining",
"mac", "mac",
"model",
"expected_hashrate", "expected_hashrate",
"uptime", "uptime",
"wattage", "wattage",
@@ -63,7 +67,7 @@ class MinersTest(unittest.TestCase):
for miner_model in MINER_CLASSES.keys(): for miner_model in MINER_CLASSES.keys():
for miner_api in MINER_CLASSES[miner_model].keys(): for miner_api in MINER_CLASSES[miner_model].keys():
with self.subTest( with self.subTest(
msg=f"Data map key check", msg=f"Data map key check of miner using model={miner_model}, api={miner_api}",
miner_model=miner_model, miner_model=miner_model,
miner_api=miner_api, miner_api=miner_api,
): ):
@@ -80,7 +84,7 @@ class MinersTest(unittest.TestCase):
miner = MINER_CLASSES[miner_model][miner_api]("127.0.0.1") miner = MINER_CLASSES[miner_model][miner_api]("127.0.0.1")
for data_point in asdict(miner.data_locations).values(): for data_point in asdict(miner.data_locations).values():
with self.subTest( with self.subTest(
msg=f"Test {data_point['cmd']} signature matches", msg=f"Test {data_point['cmd']} signature matches with model={miner_model}, api={miner_api}",
miner_model=miner_model, miner_model=miner_model,
miner_api=miner_api, miner_api=miner_api,
): ):
@@ -98,22 +102,6 @@ class MinersTest(unittest.TestCase):
set([k["name"] for k in data_point["kwargs"]]), set([k["name"] for k in data_point["kwargs"]]),
) )
def test_data_locations_use_private_funcs(self):
warnings.filterwarnings("ignore")
for miner_model in MINER_CLASSES.keys():
for miner_api in MINER_CLASSES[miner_model].keys():
miner = MINER_CLASSES[miner_model][miner_api]("127.0.0.1")
for data_point in asdict(miner.data_locations).values():
with self.subTest(
msg=f"Test {data_point['cmd']} is private",
miner_model=miner_model,
miner_api=miner_api,
):
self.assertTrue(
data_point["cmd"].startswith("_")
or data_point["cmd"] == "get_config"
)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()