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

Merge pull request #91 from UpstreamData/dev_get_params

Browse Source 
Move parameters to private methods for `get_{x}` methods
This commit is contained in:
b-rowan
2024-01-15 10:43:08 -07:00
committed by GitHub
parent 34006941ad 04ca75d00e
commit d44907435c
101 changed files with 916 additions and 1001 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
pyasic/load/__init__.py
View File

@@ -66,14 +66,14 @@ class _MinerPhaseBalancer:
str(miner.ip): {
"miner": miner,
"set": 0,
"min": miner.fan_count * FAN_USAGE,
"min": miner.expected_fans * FAN_USAGE,
}
for miner in miners
}
for miner in miners:
if (
isinstance(miner, BTMiner)
and not (miner.model.startswith("M2") if miner.model else True)
and not (miner.raw_model.startswith("M2") if miner.raw_model else True)
) or isinstance(miner, BOSMiner):
if isinstance(miner, S9):
self.miners[str(miner.ip)]["tune"] = True
@@ -98,8 +98,8 @@ class _MinerPhaseBalancer:
self.miners[str(miner.ip)]["tune"] = False
self.miners[str(miner.ip)]["shutdown"] = True
self.miners[str(miner.ip)]["max"] = 3600
if miner.model:
if miner.model.startswith("M2"):
if miner.raw_model:
if miner.raw_model.startswith("M2"):
self.miners[str(miner.ip)]["tune"] = False
self.miners[str(miner.ip)]["shutdown"] = True
self.miners[str(miner.ip)]["max"] = 2400

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

@@ -30,7 +30,7 @@ class HiveonT9(Hiveon, T9):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self):
async def _get_mac(self):
try:
mac = (
(await self.send_ssh_command("cat /sys/class/net/eth0/address"))
@@ -41,7 +41,8 @@ class HiveonT9(Hiveon, T9):
except (TypeError, ValueError, asyncssh.Error, OSError, AttributeError):
pass
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
hashboards = [
HashBoard(slot=board, expected_chips=self.expected_chips)
for board in range(self.expected_hashboards)
@@ -69,21 +70,21 @@ class HiveonT9(Hiveon, T9):
hashboards[board].chip_temp = api_stats["STATS"][1][
f"temp2_{chipset}"
]
except (KeyError, IndexError):
except LookupError:
pass
else:
hashboards[board].missing = False
try:
hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"]
chips += api_stats["STATS"][1][f"chain_acn{chipset}"]
except (KeyError, IndexError):
except LookupError:
pass
hashboards[board].hashrate = round(hashrate / 1000, 2)
hashboards[board].chips = chips
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:
try:
api_stats = await self.api.stats()
@@ -94,13 +95,13 @@ class HiveonT9(Hiveon, T9):
boards = api_stats.get("STATS")
try:
wattage_raw = boards[1]["chain_power"]
except (KeyError, IndexError):
except LookupError:
pass
else:
# parse wattage position out of raw data
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 = []
board_map = {
0: [2, 9, 10],
@@ -119,7 +120,7 @@ class HiveonT9(Hiveon, T9):
env_temp = api_stats["STATS"][1][f"temp3_{chipset}"]
if not env_temp == 0:
env_temp_list.append(int(env_temp))
except (KeyError, IndexError):
except LookupError:
pass
if not env_temp_list == []:

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

@@ -34,44 +34,43 @@ from pyasic.web.antminer import AntminerModernWebAPI, AntminerOldWebAPI
ANTMINER_MODERN_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac", [WebAPICommand("web_get_system_info", "get_system_info")]
"_get_mac", [WebAPICommand("web_get_system_info", "get_system_info")]
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [RPCAPICommand("api_version", "version")]
"_get_fw_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.HOSTNAME): DataFunction(
"get_hostname", [WebAPICommand("web_get_system_info", "get_system_info")]
"_get_hostname", [WebAPICommand("web_get_system_info", "get_system_info")]
),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction("get_hashboards", []),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.HASHBOARDS): DataFunction("_get_hashboards"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
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", [WebAPICommand("web_summary", "summary")]
"_get_errors", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.FAULT_LIGHT): DataFunction(
"get_fault_light",
"_get_fault_light",
[WebAPICommand("web_get_blink_status", "get_blink_status")],
),
str(DataOptions.IS_MINING): DataFunction(
"is_mining", [WebAPICommand("web_get_conf", "get_miner_conf")]
"_is_mining", [WebAPICommand("web_get_conf", "get_miner_conf")]
),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_stats", "stats")]
"_get_uptime", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -141,7 +140,7 @@ class AntminerModern(BMMiner):
await self.send_config(cfg)
return True
async def get_hostname(self, web_get_system_info: dict = None) -> Union[str, None]:
async def _get_hostname(self, web_get_system_info: dict = None) -> Union[str, None]:
if not web_get_system_info:
try:
web_get_system_info = await self.web.get_system_info()
@@ -154,7 +153,7 @@ class AntminerModern(BMMiner):
except KeyError:
pass
async def get_mac(self, web_get_system_info: dict = None) -> Union[str, None]:
async def _get_mac(self, web_get_system_info: dict = None) -> Union[str, None]:
if not web_get_system_info:
try:
web_get_system_info = await self.web.get_system_info()
@@ -174,7 +173,7 @@ class AntminerModern(BMMiner):
except KeyError:
pass
async def get_errors(self, web_summary: dict = None) -> List[MinerErrorData]:
async def _get_errors(self, web_summary: dict = None) -> List[MinerErrorData]:
if not web_summary:
try:
web_summary = await self.web.summary()
@@ -190,11 +189,11 @@ class AntminerModern(BMMiner):
errors.append(X19Error(item["msg"]))
except KeyError:
continue
except (KeyError, IndexError):
except LookupError:
pass
return errors
async def get_hashboards(self) -> List[HashBoard]:
async def _get_hashboards(self) -> List[HashBoard]:
hashboards = [
HashBoard(idx, expected_chips=self.expected_chips)
for idx in range(self.expected_hashboards)
@@ -230,7 +229,7 @@ class AntminerModern(BMMiner):
pass
return hashboards
async def get_fault_light(self, web_get_blink_status: dict = None) -> bool:
async def _get_fault_light(self, web_get_blink_status: dict = None) -> bool:
if self.light:
return self.light
@@ -247,7 +246,7 @@ class AntminerModern(BMMiner):
pass
return self.light
async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
if not api_stats:
try:
api_stats = await self.api.stats()
@@ -267,7 +266,7 @@ class AntminerModern(BMMiner):
return round(expected_rate / 1000000, 2)
else:
return round(expected_rate, 2)
except (KeyError, IndexError):
except LookupError:
pass
async def set_static_ip(
@@ -312,7 +311,7 @@ class AntminerModern(BMMiner):
protocol=protocol,
)
async def is_mining(self, web_get_conf: dict = None) -> Optional[bool]:
async def _is_mining(self, web_get_conf: dict = None) -> Optional[bool]:
if not web_get_conf:
try:
web_get_conf = await self.web.get_miner_conf()
@@ -329,7 +328,7 @@ class AntminerModern(BMMiner):
except LookupError:
pass
async def get_uptime(self, api_stats: dict = None) -> Optional[int]:
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]:
if not api_stats:
try:
api_stats = await self.api.stats()
@@ -345,43 +344,42 @@ class AntminerModern(BMMiner):
ANTMINER_OLD_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction("get_mac"),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.MAC): DataFunction("_get_mac"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [RPCAPICommand("api_version", "version")]
"_get_fw_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.HOSTNAME): DataFunction(
"get_hostname", [WebAPICommand("web_get_system_info", "get_system_info")]
"_get_hostname", [WebAPICommand("web_get_system_info", "get_system_info")]
),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_stats", "stats")]
"_get_hashboards", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_stats", "stats")]
"_get_fans", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction(
"get_fault_light",
"_get_fault_light",
[WebAPICommand("web_get_blink_status", "get_blink_status")],
),
str(DataOptions.IS_MINING): DataFunction(
"is_mining", [WebAPICommand("web_get_conf", "get_miner_conf")]
"_is_mining", [WebAPICommand("web_get_conf", "get_miner_conf")]
),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_stats", "stats")]
"_get_uptime", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -408,7 +406,7 @@ class AntminerOld(CGMiner):
self.config = config
await self.web.set_miner_conf(config.as_am_old(user_suffix=user_suffix))
async def get_mac(self) -> Union[str, None]:
async def _get_mac(self) -> Union[str, None]:
try:
data = await self.web.get_system_info()
if data:
@@ -445,7 +443,7 @@ class AntminerOld(CGMiner):
return True
return False
async def get_fault_light(self, web_get_blink_status: dict = None) -> bool:
async def _get_fault_light(self, web_get_blink_status: dict = None) -> bool:
if self.light:
return self.light
@@ -462,7 +460,7 @@ class AntminerOld(CGMiner):
pass
return self.light
async def get_hostname(self, web_get_system_info: dict = None) -> Optional[str]:
async def _get_hostname(self, web_get_system_info: dict = None) -> Optional[str]:
if not web_get_system_info:
try:
web_get_system_info = await self.web.get_system_info()
@@ -475,14 +473,14 @@ class AntminerOld(CGMiner):
except KeyError:
pass
async def get_fans(self, api_stats: dict = None) -> List[Fan]:
async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
if not api_stats:
try:
api_stats = await self.api.stats()
except APIError:
pass
fans_data = [Fan() for _ in range(self.fan_count)]
fans_data = [Fan() for _ in range(self.expected_fans)]
if api_stats:
try:
fan_offset = -1
@@ -495,15 +493,15 @@ class AntminerOld(CGMiner):
if fan_offset == -1:
fan_offset = 3
for fan in range(self.fan_count):
for fan in range(self.expected_fans):
fans_data[fan].speed = api_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0
)
except (KeyError, IndexError):
except LookupError:
pass
return fans_data
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
hashboards = []
if not api_stats:
@@ -552,12 +550,12 @@ class AntminerOld(CGMiner):
if (not chips) or (not chips > 0):
hashboard.missing = True
hashboards.append(hashboard)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
return hashboards
async def is_mining(self, web_get_conf: dict = None) -> Optional[bool]:
async def _is_mining(self, web_get_conf: dict = None) -> Optional[bool]:
if not web_get_conf:
try:
web_get_conf = await self.web.get_miner_conf()
@@ -582,7 +580,7 @@ class AntminerOld(CGMiner):
else:
return False
async def get_uptime(self, api_stats: dict = None) -> Optional[int]:
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]:
if not api_stats:
try:
api_stats = await self.api.stats()

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

@@ -14,8 +14,7 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
from collections import namedtuple
from typing import List, Optional, Tuple
from typing import List, Optional
from pyasic.API.bfgminer import BFGMinerAPI
from pyasic.config import MinerConfig
@@ -32,35 +31,34 @@ from pyasic.miners.base import (
BFGMINER_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction("get_mac"),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.MAC): DataFunction("_get_mac"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [RPCAPICommand("api_version", "version")]
"_get_fw_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_stats", "stats")]
"_get_hashboards", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_stats", "stats")]
"_get_fans", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.UPTIME): DataFunction("get_uptime"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction("_get_uptime"),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
)
@@ -117,14 +115,10 @@ class BFGMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self) -> str:
return "00:00:00:00:00:00"
async def get_api_ver(self, api_version: dict = None) -> Optional[str]:
# Check to see if the version info is already cached
if self.api_ver:
return self.api_ver
async def _get_mac(self) -> Optional[str]:
return None
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -134,16 +128,12 @@ class BFGMiner(BaseMiner):
if api_version:
try:
self.api_ver = api_version["VERSION"][0]["API"]
except (KeyError, IndexError):
except LookupError:
pass
return self.api_ver
async def get_fw_ver(self, api_version: dict = None) -> Optional[str]:
# Check to see if the version info is already cached
if self.fw_ver:
return self.fw_ver
async def _get_fw_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -153,31 +143,21 @@ class BFGMiner(BaseMiner):
if api_version:
try:
self.fw_ver = api_version["VERSION"][0]["CompileTime"]
except (KeyError, IndexError):
except LookupError:
pass
return self.fw_ver
async def get_version(
self, api_version: dict = None
) -> Tuple[Optional[str], Optional[str]]:
# check if version is cached
miner_version = namedtuple("MinerVersion", "api_ver fw_ver")
return miner_version(
api_ver=await self.get_api_ver(api_version),
fw_ver=await self.get_fw_ver(api_version=api_version),
)
async def reboot(self) -> bool:
return False
async def get_fan_psu(self):
async def _get_fan_psu(self):
return None
async def get_hostname(self) -> Optional[str]:
async def _get_hostname(self) -> Optional[str]:
return None
async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
# get hr from API
if not api_summary:
try:
@@ -188,10 +168,10 @@ class BFGMiner(BaseMiner):
if api_summary:
try:
return round(float(api_summary["SUMMARY"][0]["MHS 20s"] / 1000000), 2)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
hashboards = []
if not api_stats:
@@ -240,21 +220,21 @@ class BFGMiner(BaseMiner):
if (not chips) or (not chips > 0):
hashboard.missing = True
hashboards.append(hashboard)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
return hashboards
async def get_env_temp(self) -> Optional[float]:
async def _get_env_temp(self) -> Optional[float]:
return None
async def get_wattage(self) -> Optional[int]:
async def _get_wattage(self) -> Optional[int]:
return None
async def get_wattage_limit(self) -> Optional[int]:
async def _get_wattage_limit(self) -> Optional[int]:
return None
async def get_fans(self, api_stats: dict = None) -> List[Fan]:
async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
if not api_stats:
try:
api_stats = await self.api.stats()
@@ -274,23 +254,23 @@ class BFGMiner(BaseMiner):
if fan_offset == -1:
fan_offset = 1
for fan in range(self.fan_count):
for fan in range(self.expected_fans):
fans_data[fan] = api_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0
)
except (KeyError, IndexError):
except LookupError:
pass
fans = [Fan(speed=d) if d else Fan() for d in fans_data]
return fans
async def get_errors(self) -> List[MinerErrorData]:
async def _get_errors(self) -> List[MinerErrorData]:
return []
async def get_fault_light(self) -> bool:
async def _get_fault_light(self) -> bool:
return False
async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
# X19 method, not sure compatibility
if not api_stats:
try:
@@ -311,11 +291,11 @@ class BFGMiner(BaseMiner):
return round(expected_rate / 1000000, 2)
else:
return round(expected_rate, 2)
except (KeyError, IndexError):
except LookupError:
pass
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, *args, **kwargs) -> Optional[int]:
async def _get_uptime(self, *args, **kwargs) -> Optional[int]:
return None

43
pyasic/miners/backends/bfgminer_goldshell.py
View File

@@ -32,40 +32,39 @@ from pyasic.web.goldshell import GoldshellWebAPI
GOLDSHELL_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac", [WebAPICommand("web_setting", "setting")]
"_get_mac", [WebAPICommand("web_setting", "setting")]
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [WebAPICommand("web_status", "status")]
"_get_fw_ver", [WebAPICommand("web_status", "status")]
),
str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards",
"_get_hashboards",
[
RPCAPICommand("api_devs", "devs"),
RPCAPICommand("api_devdetails", "devdetails"),
],
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_stats", "stats")]
"_get_fans", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.UPTIME): DataFunction("get_uptime"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction("_get_uptime"),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
)
@@ -110,7 +109,7 @@ class BFGMinerGoldshell(BFGMiner):
url=pool["url"], user=pool["user"], password=pool["pass"]
)
async def get_mac(self, web_setting: dict = None) -> str:
async def _get_mac(self, web_setting: dict = None) -> str:
if not web_setting:
try:
web_setting = await self.web.setting()
@@ -123,7 +122,7 @@ class BFGMinerGoldshell(BFGMiner):
except KeyError:
pass
async def get_fw_ver(self, web_status: dict = None) -> str:
async def _get_fw_ver(self, web_status: dict = None) -> str:
if not web_status:
try:
web_status = await self.web.setting()
@@ -136,7 +135,7 @@ class BFGMinerGoldshell(BFGMiner):
except KeyError:
pass
async def get_hashboards(
async def _get_hashboards(
self, api_devs: dict = None, api_devdetails: dict = None
) -> List[HashBoard]:
if not api_devs:
@@ -186,8 +185,8 @@ class BFGMinerGoldshell(BFGMiner):
return hashboards
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, *args, **kwargs) -> Optional[int]:
async def _get_uptime(self, *args, **kwargs) -> Optional[int]:
return None

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

@@ -15,8 +15,7 @@
# ------------------------------------------------------------------------------
import logging
from collections import namedtuple
from typing import List, Optional, Tuple
from typing import List, Optional
from pyasic.API.bmminer import BMMinerAPI
from pyasic.config import MinerConfig
@@ -33,36 +32,35 @@ from pyasic.miners.base import (
BMMINER_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction("get_mac"),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.MAC): DataFunction("_get_mac"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [RPCAPICommand("api_version", "version")]
"_get_fw_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_stats", "stats")]
"_get_hashboards", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_stats", "stats")]
"_get_fans", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_stats", "stats")]
"_get_uptime", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -156,14 +154,10 @@ class BMMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self) -> str:
return "00:00:00:00:00:00"
async def get_api_ver(self, api_version: dict = None) -> Optional[str]:
# Check to see if the version info is already cached
if self.api_ver:
return self.api_ver
async def _get_mac(self) -> Optional[str]:
return None
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -173,16 +167,12 @@ class BMMiner(BaseMiner):
if api_version:
try:
self.api_ver = api_version["VERSION"][0]["API"]
except (KeyError, IndexError):
except LookupError:
pass
return self.api_ver
async def get_fw_ver(self, api_version: dict = None) -> Optional[str]:
# Check to see if the version info is already cached
if self.fw_ver:
return self.fw_ver
async def _get_fw_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -192,29 +182,19 @@ class BMMiner(BaseMiner):
if api_version:
try:
self.fw_ver = api_version["VERSION"][0]["CompileTime"]
except (KeyError, IndexError):
except LookupError:
pass
return self.fw_ver
async def get_version(
self, api_version: dict = None
) -> Tuple[Optional[str], Optional[str]]:
# check if version is cached
miner_version = namedtuple("MinerVersion", "api_ver fw_ver")
return miner_version(
api_ver=await self.get_api_ver(api_version),
fw_ver=await self.get_fw_ver(api_version=api_version),
)
async def get_fan_psu(self):
async def _get_fan_psu(self):
return None
async def get_hostname(self) -> Optional[str]:
async def _get_hostname(self) -> Optional[str]:
hn = await self.send_ssh_command("cat /proc/sys/kernel/hostname")
return hn
async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
# get hr from API
if not api_summary:
try:
@@ -225,10 +205,10 @@ class BMMiner(BaseMiner):
if api_summary:
try:
return round(float(api_summary["SUMMARY"][0]["GHS 5s"] / 1000), 2)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
hashboards = []
if not api_stats:
@@ -295,23 +275,23 @@ class BMMiner(BaseMiner):
return hashboards
async def get_env_temp(self) -> Optional[float]:
async def _get_env_temp(self) -> Optional[float]:
return None
async def get_wattage(self) -> Optional[int]:
async def _get_wattage(self) -> Optional[int]:
return None
async def get_wattage_limit(self) -> Optional[int]:
async def _get_wattage_limit(self) -> Optional[int]:
return None
async def get_fans(self, api_stats: dict = None) -> List[Fan]:
async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
if not api_stats:
try:
api_stats = await self.api.stats()
except APIError:
pass
fans = [Fan() for _ in range(self.fan_count)]
fans = [Fan() for _ in range(self.expected_fans)]
if api_stats:
try:
fan_offset = -1
@@ -324,22 +304,22 @@ class BMMiner(BaseMiner):
if fan_offset == -1:
fan_offset = 1
for fan in range(self.fan_count):
for fan in range(self.expected_fans):
fans[fan].speed = api_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0
)
except (KeyError, IndexError):
except LookupError:
pass
return fans
async def get_errors(self) -> List[MinerErrorData]:
async def _get_errors(self) -> List[MinerErrorData]:
return []
async def get_fault_light(self) -> bool:
async def _get_fault_light(self) -> bool:
return False
async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
# X19 method, not sure compatibility
if not api_stats:
try:
@@ -360,16 +340,16 @@ class BMMiner(BaseMiner):
return round(expected_rate / 1000000, 2)
else:
return round(expected_rate, 2)
except (KeyError, IndexError):
except LookupError:
pass
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, api_stats: dict = None) -> Optional[int]:
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]:
if not api_stats:
try:
api_stats = await self.web.get_miner_conf()
api_stats = await self.api.stats()
except APIError:
pass

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

@@ -41,19 +41,18 @@ from pyasic.web.bosminer import BOSMinerWebAPI
BOSMINER_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac",
"_get_mac",
[
WebAPICommand(
"web_net_conf", "/cgi-bin/luci/admin/network/iface_status/lan"
)
],
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver",
"_get_fw_ver",
[
GraphQLCommand(
"graphql_version", {"bos": {"info": {"version": {"full": None}}}}
@@ -61,11 +60,11 @@ BOSMINER_DATA_LOC = DataLocations(
],
),
str(DataOptions.HOSTNAME): DataFunction(
"get_hostname",
"_get_hostname",
[GraphQLCommand("graphql_hostname", {"bos": {"hostname": None}})],
),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate",
"_get_hashrate",
[
RPCAPICommand("api_summary", "summary"),
GraphQLCommand(
@@ -79,10 +78,10 @@ BOSMINER_DATA_LOC = DataLocations(
],
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_devs", "devs")]
"_get_expected_hashrate", [RPCAPICommand("api_devs", "devs")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards",
"_get_hashboards",
[
RPCAPICommand("api_temps", "temps"),
RPCAPICommand("api_devdetails", "devdetails"),
@@ -106,9 +105,9 @@ BOSMINER_DATA_LOC = DataLocations(
),
],
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction(
"get_wattage",
"_get_wattage",
[
RPCAPICommand("api_tunerstatus", "tunerstatus"),
GraphQLCommand(
@@ -124,7 +123,7 @@ BOSMINER_DATA_LOC = DataLocations(
],
),
str(DataOptions.WATTAGE_LIMIT): DataFunction(
"get_wattage_limit",
"_get_wattage_limit",
[
RPCAPICommand("api_tunerstatus", "tunerstatus"),
GraphQLCommand(
@@ -134,7 +133,7 @@ BOSMINER_DATA_LOC = DataLocations(
],
),
str(DataOptions.FANS): DataFunction(
"get_fans",
"_get_fans",
[
RPCAPICommand("api_fans", "fans"),
GraphQLCommand(
@@ -143,9 +142,9 @@ BOSMINER_DATA_LOC = DataLocations(
),
],
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction(
"get_errors",
"_get_errors",
[
RPCAPICommand("api_tunerstatus", "tunerstatus"),
GraphQLCommand(
@@ -166,14 +165,14 @@ BOSMINER_DATA_LOC = DataLocations(
],
),
str(DataOptions.FAULT_LIGHT): DataFunction(
"get_fault_light",
"_get_fault_light",
[GraphQLCommand("graphql_fault_light", {"bos": {"faultLight": None}})],
),
str(DataOptions.IS_MINING): DataFunction(
"is_mining", [RPCAPICommand("api_devdetails", "devdetails")]
"_is_mining", [RPCAPICommand("api_devdetails", "devdetails")]
),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_summary", "summary")]
"_get_uptime", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -189,6 +188,7 @@ class BOSMiner(BaseMiner):
# static data
self.api_type = "BOSMiner"
self.fw_str = "BOS"
# data gathering locations
self.data_locations = BOSMINER_DATA_LOC
# autotuning/shutdown support
@@ -329,7 +329,7 @@ class BOSMiner(BaseMiner):
"format": {
"version": "1.2+",
"generator": "pyasic",
"model": f"{self.make.replace('Miner', 'miner')} {self.model.replace(' (BOS)', '').replace('j', 'J')}",
"raw_model": f"{self.make.replace('Miner', 'miner')} {self.raw_model}",
"timestamp": int(time.time()),
},
**config.as_bosminer(user_suffix=user_suffix),
@@ -428,7 +428,7 @@ class BOSMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self, web_net_conf: Union[dict, list] = None) -> Optional[str]:
async def _get_mac(self, web_net_conf: Union[dict, list] = None) -> Optional[str]:
if not web_net_conf:
try:
web_net_conf = await self.web.send_command(
@@ -454,8 +454,8 @@ class BOSMiner(BaseMiner):
# return result.upper().strip()
async def get_model(self) -> Optional[str]:
if self.model is not None:
return self.model + " (BOS)"
if self.raw_model is not None:
return self.raw_model + " (BOS)"
return "? (BOS)"
async def get_version(
@@ -467,7 +467,7 @@ class BOSMiner(BaseMiner):
fw_ver = await self.get_fw_ver(graphql_version)
return miner_version(api_ver, fw_ver)
async def get_api_ver(self, api_version: dict = None) -> Optional[str]:
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -478,14 +478,14 @@ class BOSMiner(BaseMiner):
if api_version:
try:
api_ver = api_version["VERSION"][0]["API"]
except (KeyError, IndexError):
except LookupError:
api_ver = None
self.api_ver = api_ver
self.api.api_ver = self.api_ver
return self.api_ver
async def get_fw_ver(self, graphql_version: dict = None) -> Optional[str]:
async def _get_fw_ver(self, graphql_version: dict = None) -> Optional[str]:
if not graphql_version:
try:
graphql_version = await self.web.send_command(
@@ -515,7 +515,7 @@ class BOSMiner(BaseMiner):
return self.fw_ver
async def get_hostname(self, graphql_hostname: dict = None) -> Union[str, None]:
async def _get_hostname(self, graphql_hostname: dict = None) -> Union[str, None]:
hostname = None
if not graphql_hostname:
@@ -544,7 +544,7 @@ class BOSMiner(BaseMiner):
logging.warning(f"Failed to get hostname for miner: {self}, {e}")
return hostname
async def get_hashrate(
async def _get_hashrate(
self, api_summary: dict = None, graphql_hashrate: dict = None
) -> Optional[float]:
# get hr from graphql
@@ -580,10 +580,10 @@ class BOSMiner(BaseMiner):
if api_summary:
try:
return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
except (KeyError, IndexError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
async def get_hashboards(
async def _get_hashboards(
self,
api_temps: dict = None,
api_devdetails: dict = None,
@@ -642,7 +642,7 @@ class BOSMiner(BaseMiner):
board.temp = round(hb["temperatures"][0]["degreesC"])
if len(temps) > 1:
board.chip_temp = round(hb["temperatures"][1]["degreesC"])
except (TypeError, KeyError, ValueError, IndexError):
except (LookupError, TypeError, ValueError):
pass
details = hb.get("hwDetails")
if details:
@@ -666,15 +666,15 @@ class BOSMiner(BaseMiner):
d = {}
try:
api_temps = d["temps"][0]
except (KeyError, IndexError):
except LookupError:
api_temps = None
try:
api_devdetails = d["devdetails"][0]
except (KeyError, IndexError):
except LookupError:
api_devdetails = None
try:
api_devs = d["devs"][0]
except (KeyError, IndexError):
except LookupError:
api_devs = None
if api_temps:
try:
@@ -686,7 +686,7 @@ class BOSMiner(BaseMiner):
board_temp = round(board["Board"])
hashboards[_id].chip_temp = chip_temp
hashboards[_id].temp = board_temp
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
if api_devdetails:
@@ -698,7 +698,7 @@ class BOSMiner(BaseMiner):
chips = board["Chips"]
hashboards[_id].chips = chips
hashboards[_id].missing = False
except (IndexError, KeyError):
except LookupError:
pass
if api_devs:
@@ -709,15 +709,15 @@ class BOSMiner(BaseMiner):
_id = board["ID"] - offset
hashrate = round(float(board["MHS 1m"] / 1000000), 2)
hashboards[_id].hashrate = hashrate
except (IndexError, KeyError):
except LookupError:
pass
return hashboards
async def get_env_temp(self) -> Optional[float]:
async def _get_env_temp(self) -> Optional[float]:
return None
async def get_wattage(
async def _get_wattage(
self, api_tunerstatus: dict = None, graphql_wattage: dict = None
) -> Optional[int]:
if not graphql_wattage and not api_tunerstatus:
@@ -750,10 +750,10 @@ class BOSMiner(BaseMiner):
return api_tunerstatus["TUNERSTATUS"][0][
"ApproximateMinerPowerConsumption"
]
except (KeyError, IndexError):
except LookupError:
pass
async def get_wattage_limit(
async def _get_wattage_limit(
self, api_tunerstatus: dict = None, graphql_wattage_limit: dict = None
) -> Optional[int]:
if not graphql_wattage_limit and not api_tunerstatus:
@@ -781,10 +781,10 @@ class BOSMiner(BaseMiner):
if api_tunerstatus:
try:
return api_tunerstatus["TUNERSTATUS"][0]["PowerLimit"]
except (KeyError, IndexError):
except LookupError:
pass
async def get_fans(
async def _get_fans(
self, api_fans: dict = None, graphql_fans: dict = None
) -> List[Fan]:
if not graphql_fans and not api_fans:
@@ -796,7 +796,7 @@ class BOSMiner(BaseMiner):
pass
if graphql_fans.get("data"):
fans = []
for n in range(self.fan_count):
for n in range(self.expected_fans):
try:
fans.append(
Fan(
@@ -817,18 +817,18 @@ class BOSMiner(BaseMiner):
if api_fans:
fans = []
for n in range(self.fan_count):
for n in range(self.expected_fans):
try:
fans.append(Fan(api_fans["FANS"][n]["RPM"]))
except (IndexError, KeyError):
except LookupError:
pass
return fans
return [Fan() for _ in range(self.fan_count)]
return [Fan() for _ in range(self.expected_fans)]
async def get_fan_psu(self) -> Optional[int]:
async def _get_fan_psu(self) -> Optional[int]:
return None
async def get_errors(
async def _get_errors(
self, api_tunerstatus: dict = None, graphql_errors: dict = None
) -> List[MinerErrorData]:
if not graphql_errors and not api_tunerstatus:
@@ -904,10 +904,10 @@ class BOSMiner(BaseMiner):
_error = _error[0].lower() + _error[1:]
errors.append(BraiinsOSError(f"Slot {_id} {_error}"))
return errors
except (KeyError, IndexError):
except LookupError:
pass
async def get_fault_light(self, graphql_fault_light: dict = None) -> bool:
async def _get_fault_light(self, graphql_fault_light: dict = None) -> bool:
if self.light:
return self.light
@@ -964,7 +964,7 @@ class BOSMiner(BaseMiner):
except (TypeError, AttributeError):
return self.light
async def get_expected_hashrate(self, api_devs: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, api_devs: dict = None) -> Optional[float]:
if not api_devs:
try:
api_devs = await self.api.devs()
@@ -987,10 +987,10 @@ class BOSMiner(BaseMiner):
return round(
(sum(hr_list) / len(hr_list)) * self.expected_hashboards, 2
)
except (IndexError, KeyError):
except LookupError:
pass
async def is_mining(self, api_devdetails: dict = None) -> Optional[bool]:
async def _is_mining(self, api_devdetails: dict = None) -> Optional[bool]:
if not api_devdetails:
try:
api_devdetails = await self.api.send_command(
@@ -1005,7 +1005,7 @@ class BOSMiner(BaseMiner):
except LookupError:
pass
async def get_uptime(self, api_summary: dict = None) -> Optional[int]:
async def _get_uptime(self, api_summary: dict = None) -> Optional[int]:
if not api_summary:
try:
api_summary = await self.api.summary()

32
pyasic/miners/backends/bosminer_old.py
View File

@@ -93,7 +93,7 @@ class BOSMinerOld(BOSMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self, *args, **kwargs) -> Optional[str]:
async def _get_mac(self, *args, **kwargs) -> Optional[str]:
return None
async def get_model(self, *args, **kwargs) -> str:
@@ -102,54 +102,54 @@ class BOSMinerOld(BOSMiner):
async def get_version(self, *args, **kwargs) -> Tuple[Optional[str], Optional[str]]:
return None, None
async def get_hostname(self, *args, **kwargs) -> Optional[str]:
async def _get_hostname(self, *args, **kwargs) -> Optional[str]:
return None
async def get_hashrate(self, *args, **kwargs) -> Optional[float]:
async def _get_hashrate(self, *args, **kwargs) -> Optional[float]:
return None
async def get_hashboards(self, *args, **kwargs) -> List[HashBoard]:
async def _get_hashboards(self, *args, **kwargs) -> List[HashBoard]:
return []
async def get_env_temp(self, *args, **kwargs) -> Optional[float]:
async def _get_env_temp(self, *args, **kwargs) -> Optional[float]:
return None
async def get_wattage(self, *args, **kwargs) -> Optional[int]:
async def _get_wattage(self, *args, **kwargs) -> Optional[int]:
return None
async def get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
async def _get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
return None
async def get_fans(
async def _get_fans(
self,
*args,
**kwargs,
) -> List[Fan]:
return [Fan(), Fan(), Fan(), Fan()]
async def get_fan_psu(self, *args, **kwargs) -> Optional[int]:
async def _get_fan_psu(self, *args, **kwargs) -> Optional[int]:
return None
async def get_api_ver(self, *args, **kwargs) -> Optional[str]:
async def _get_api_ver(self, *args, **kwargs) -> Optional[str]:
return None
async def get_fw_ver(self, *args, **kwargs) -> Optional[str]:
async def _get_fw_ver(self, *args, **kwargs) -> Optional[str]:
return None
async def get_errors(self, *args, **kwargs) -> List[MinerErrorData]:
async def _get_errors(self, *args, **kwargs) -> List[MinerErrorData]:
return []
async def get_fault_light(self, *args, **kwargs) -> bool:
async def _get_fault_light(self, *args, **kwargs) -> bool:
return False
async def get_expected_hashrate(self, *args, **kwargs) -> Optional[float]:
async def _get_expected_hashrate(self, *args, **kwargs) -> Optional[float]:
return None
async def get_data(self, allow_warning: bool = False, **kwargs) -> MinerData:
return MinerData(ip=str(self.ip))
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, *args, **kwargs) -> Optional[int]:
async def _get_uptime(self, *args, **kwargs) -> Optional[int]:
return None

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

@@ -15,8 +15,7 @@
# ------------------------------------------------------------------------------
import logging
from collections import namedtuple
from typing import List, Optional, Tuple
from typing import List, Optional
from pyasic.API.btminer import BTMinerAPI
from pyasic.config import MinerConfig, MiningModeConfig
@@ -29,80 +28,78 @@ from pyasic.miners.base import (
DataLocations,
DataOptions,
RPCAPICommand,
WebAPICommand,
)
BTMINER_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac",
"_get_mac",
[
RPCAPICommand("api_summary", "summary"),
RPCAPICommand("api_get_miner_info", "get_miner_info"),
],
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_get_version", "get_version")]
"_get_api_ver", [RPCAPICommand("api_get_version", "get_version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver",
"_get_fw_ver",
[
RPCAPICommand("api_get_version", "get_version"),
RPCAPICommand("api_summary", "summary"),
],
),
str(DataOptions.HOSTNAME): DataFunction(
"get_hostname", [RPCAPICommand("api_get_miner_info", "get_miner_info")]
"_get_hostname", [RPCAPICommand("api_get_miner_info", "get_miner_info")]
),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_expected_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_devs", "devs")]
"_get_hashboards", [RPCAPICommand("api_devs", "devs")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
"get_env_temp", [RPCAPICommand("api_summary", "summary")]
"_get_env_temp", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.WATTAGE): DataFunction(
"get_wattage", [RPCAPICommand("api_summary", "summary")]
"_get_wattage", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.WATTAGE_LIMIT): DataFunction(
"get_wattage_limit", [RPCAPICommand("api_summary", "summary")]
"_get_wattage_limit", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.FANS): DataFunction(
"get_fans",
"_get_fans",
[
RPCAPICommand("api_summary", "summary"),
RPCAPICommand("api_get_psu", "get_psu"),
],
),
str(DataOptions.FAN_PSU): DataFunction(
"get_fan_psu",
"_get_fan_psu",
[
RPCAPICommand("api_summary", "summary"),
RPCAPICommand("api_get_psu", "get_psu"),
],
),
str(DataOptions.ERRORS): DataFunction(
"get_errors",
"_get_errors",
[
RPCAPICommand("api_get_error_code", "get_error_code"),
RPCAPICommand("api_summary", "summary"),
],
),
str(DataOptions.FAULT_LIGHT): DataFunction(
"get_fault_light",
"_get_fault_light",
[RPCAPICommand("api_get_miner_info", "get_miner_info")],
),
str(DataOptions.IS_MINING): DataFunction(
"is_mining", [RPCAPICommand("api_status", "status")]
"_is_mining", [RPCAPICommand("api_status", "status")]
),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_summary", "summary")]
"_get_uptime", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -243,7 +240,7 @@ class BTMiner(BaseMiner):
else:
cfg = MinerConfig()
is_mining = await self.is_mining(status)
is_mining = await self._is_mining(status)
if not is_mining:
cfg.mining_mode = MiningModeConfig.sleep()
return cfg
@@ -287,7 +284,7 @@ class BTMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(
async def _get_mac(
self, api_summary: dict = None, api_get_miner_info: dict = None
) -> Optional[str]:
if not api_get_miner_info:
@@ -313,24 +310,10 @@ class BTMiner(BaseMiner):
try:
mac = api_summary["SUMMARY"][0]["MAC"]
return str(mac).upper()
except (KeyError, IndexError):
except LookupError:
pass
async def get_version(
self, api_get_version: dict = None, api_summary: dict = None
) -> Tuple[Optional[str], Optional[str]]:
miner_version = namedtuple("MinerVersion", "api_ver fw_ver")
api_ver = await self.get_api_ver(api_get_version=api_get_version)
fw_ver = await self.get_fw_ver(
api_get_version=api_get_version, api_summary=api_summary
)
return miner_version(api_ver, fw_ver)
async def get_api_ver(self, api_get_version: dict = None) -> Optional[str]:
# Check to see if the version info is already cached
if self.api_ver:
return self.api_ver
async def _get_api_ver(self, api_get_version: dict = None) -> Optional[str]:
if not api_get_version:
try:
api_get_version = await self.api.get_version()
@@ -353,13 +336,9 @@ class BTMiner(BaseMiner):
return self.api_ver
async def get_fw_ver(
async def _get_fw_ver(
self, api_get_version: dict = None, api_summary: dict = None
) -> Optional[str]:
# Check to see if the version info is already cached
if self.fw_ver:
return self.fw_ver
if not api_get_version:
try:
api_get_version = await self.api.get_version()
@@ -387,12 +366,12 @@ class BTMiner(BaseMiner):
self.fw_ver = api_summary["SUMMARY"][0]["Firmware Version"].replace(
"'", ""
)
except (KeyError, IndexError):
except LookupError:
pass
return self.fw_ver
async def get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]:
async def _get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]:
hostname = None
if not api_get_miner_info:
try:
@@ -408,7 +387,7 @@ class BTMiner(BaseMiner):
return hostname
async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
# get hr from API
if not api_summary:
try:
@@ -419,10 +398,10 @@ class BTMiner(BaseMiner):
if api_summary:
try:
return round(float(api_summary["SUMMARY"][0]["MHS 1m"] / 1000000), 2)
except (KeyError, IndexError):
except LookupError:
pass
async def get_hashboards(self, api_devs: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_devs: dict = None) -> List[HashBoard]:
hashboards = [
HashBoard(slot=i, expected_chips=self.expected_chips)
for i in range(self.expected_hashboards)
@@ -452,12 +431,12 @@ class BTMiner(BaseMiner):
hashboards[board["ASC"]].chips = board["Effective Chips"]
hashboards[board["ASC"]].serial_number = board["PCB SN"]
hashboards[board["ASC"]].missing = False
except (KeyError, IndexError):
except LookupError:
pass
return hashboards
async def get_env_temp(self, api_summary: dict = None) -> Optional[float]:
async def _get_env_temp(self, api_summary: dict = None) -> Optional[float]:
if not api_summary:
try:
api_summary = await self.api.summary()
@@ -467,10 +446,10 @@ class BTMiner(BaseMiner):
if api_summary:
try:
return api_summary["SUMMARY"][0]["Env Temp"]
except (KeyError, IndexError):
except LookupError:
pass
async def get_wattage(self, api_summary: dict = None) -> Optional[int]:
async def _get_wattage(self, api_summary: dict = None) -> Optional[int]:
if not api_summary:
try:
api_summary = await self.api.summary()
@@ -481,10 +460,10 @@ class BTMiner(BaseMiner):
try:
wattage = api_summary["SUMMARY"][0]["Power"]
return wattage if not wattage == -1 else None
except (KeyError, IndexError):
except LookupError:
pass
async def get_wattage_limit(self, api_summary: dict = None) -> Optional[int]:
async def _get_wattage_limit(self, api_summary: dict = None) -> Optional[int]:
if not api_summary:
try:
api_summary = await self.api.summary()
@@ -494,10 +473,10 @@ class BTMiner(BaseMiner):
if api_summary:
try:
return api_summary["SUMMARY"][0]["Power Limit"]
except (KeyError, IndexError):
except LookupError:
pass
async def get_fans(
async def _get_fans(
self, api_summary: dict = None, api_get_psu: dict = None
) -> List[Fan]:
if not api_summary:
@@ -506,20 +485,20 @@ class BTMiner(BaseMiner):
except APIError:
pass
fans = [Fan() for _ in range(self.fan_count)]
fans = [Fan() for _ in range(self.expected_fans)]
if api_summary:
try:
if self.fan_count > 0:
if self.expected_fans > 0:
fans = [
Fan(api_summary["SUMMARY"][0].get("Fan Speed In", 0)),
Fan(api_summary["SUMMARY"][0].get("Fan Speed Out", 0)),
]
except (KeyError, IndexError):
except LookupError:
pass
return fans
async def get_fan_psu(
async def _get_fan_psu(
self, api_summary: dict = None, api_get_psu: dict = None
) -> Optional[int]:
if not api_summary:
@@ -531,7 +510,7 @@ class BTMiner(BaseMiner):
if api_summary:
try:
return int(api_summary["SUMMARY"][0]["Power Fanspeed"])
except (KeyError, IndexError):
except LookupError:
pass
if not api_get_psu:
@@ -546,7 +525,7 @@ class BTMiner(BaseMiner):
except (KeyError, TypeError):
pass
async def get_errors(
async def _get_errors(
self, api_summary: dict = None, api_get_error_code: dict = None
) -> List[MinerErrorData]:
errors = []
@@ -576,12 +555,12 @@ class BTMiner(BaseMiner):
err = api_summary["SUMMARY"][0].get(f"Error Code {i}")
if err:
errors.append(WhatsminerError(error_code=err))
except (KeyError, IndexError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
return errors
async def get_expected_hashrate(self, api_summary: dict = None):
async def _get_expected_hashrate(self, api_summary: dict = None):
if not api_summary:
try:
api_summary = await self.api.summary()
@@ -593,10 +572,10 @@ class BTMiner(BaseMiner):
expected_hashrate = api_summary["SUMMARY"][0]["Factory GHS"]
if expected_hashrate:
return round(expected_hashrate / 1000, 2)
except (KeyError, IndexError):
except LookupError:
pass
async def get_fault_light(self, api_get_miner_info: dict = None) -> bool:
async def _get_fault_light(self, api_get_miner_info: dict = None) -> bool:
if not api_get_miner_info:
try:
api_get_miner_info = await self.api.get_miner_info()
@@ -634,7 +613,7 @@ class BTMiner(BaseMiner):
async def set_hostname(self, hostname: str):
await self.api.set_hostname(hostname)
async def is_mining(self, api_status: dict = None) -> Optional[bool]:
async def _is_mining(self, api_status: dict = None) -> Optional[bool]:
if not api_status:
try:
api_status = await self.api.status()
@@ -653,7 +632,7 @@ class BTMiner(BaseMiner):
except LookupError:
pass
async def get_uptime(self, api_summary: dict = None) -> Optional[int]:
async def _get_uptime(self, api_summary: dict = None) -> Optional[int]:
if not api_summary:
try:
api_summary = await self.api.summary()

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

@@ -15,8 +15,7 @@
# ------------------------------------------------------------------------------
import logging
from collections import namedtuple
from typing import List, Optional, Tuple
from typing import List, Optional
from pyasic.API.cgminer import CGMinerAPI
from pyasic.config import MinerConfig
@@ -33,36 +32,35 @@ from pyasic.miners.base import (
CGMINER_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction("get_mac"),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.MAC): DataFunction("_get_mac"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [RPCAPICommand("api_version", "version")]
"_get_fw_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_stats", "stats")]
"_get_hashboards", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_stats", "stats")]
"_get_fans", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_stats", "stats")]
"_get_uptime", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -181,22 +179,10 @@ class CGMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self) -> Optional[str]:
async def _get_mac(self) -> Optional[str]:
return None
async def get_version(
self, api_version: dict = None
) -> Tuple[Optional[str], Optional[str]]:
miner_version = namedtuple("MinerVersion", "api_ver fw_ver")
return miner_version(
api_ver=await self.get_api_ver(api_version=api_version),
fw_ver=await self.get_fw_ver(api_version=api_version),
)
async def get_api_ver(self, api_version: dict = None) -> Optional[str]:
if self.api_ver:
return self.api_ver
async def _get_api_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -206,15 +192,12 @@ class CGMiner(BaseMiner):
if api_version:
try:
self.api_ver = api_version["VERSION"][0]["API"]
except (KeyError, IndexError):
except LookupError:
pass
return self.api_ver
async def get_fw_ver(self, api_version: dict = None) -> Optional[str]:
if self.fw_ver:
return self.fw_ver
async def _get_fw_ver(self, api_version: dict = None) -> Optional[str]:
if not api_version:
try:
api_version = await self.api.version()
@@ -224,16 +207,16 @@ class CGMiner(BaseMiner):
if api_version:
try:
self.fw_ver = api_version["VERSION"][0]["CGMiner"]
except (KeyError, IndexError):
except LookupError:
pass
return self.fw_ver
async def get_hostname(self) -> Optional[str]:
async def _get_hostname(self) -> Optional[str]:
hn = await self.send_ssh_command("cat /proc/sys/kernel/hostname")
return hn
async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
# get hr from API
if not api_summary:
try:
@@ -246,10 +229,10 @@ class CGMiner(BaseMiner):
return round(
float(float(api_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2
)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
hashboards = []
if not api_stats:
@@ -298,28 +281,28 @@ class CGMiner(BaseMiner):
if (not chips) or (not chips > 0):
hashboard.missing = True
hashboards.append(hashboard)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
return hashboards
async def get_env_temp(self) -> Optional[float]:
async def _get_env_temp(self) -> Optional[float]:
return None
async def get_wattage(self) -> Optional[int]:
async def _get_wattage(self) -> Optional[int]:
return None
async def get_wattage_limit(self) -> Optional[int]:
async def _get_wattage_limit(self) -> Optional[int]:
return None
async def get_fans(self, api_stats: dict = None) -> List[Fan]:
async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
if not api_stats:
try:
api_stats = await self.api.stats()
except APIError:
pass
fans = [Fan() for _ in range(self.fan_count)]
fans = [Fan() for _ in range(self.expected_fans)]
if api_stats:
try:
fan_offset = -1
@@ -332,24 +315,24 @@ class CGMiner(BaseMiner):
if fan_offset == -1:
fan_offset = 1
for fan in range(self.fan_count):
for fan in range(self.expected_fans):
fans[fan].speed = api_stats["STATS"][1].get(
f"fan{fan_offset+fan}", 0
)
except (KeyError, IndexError):
except LookupError:
pass
return fans
async def get_fan_psu(self) -> Optional[int]:
async def _get_fan_psu(self) -> Optional[int]:
return None
async def get_errors(self) -> List[MinerErrorData]:
async def _get_errors(self) -> List[MinerErrorData]:
return []
async def get_fault_light(self) -> bool:
async def _get_fault_light(self) -> bool:
return False
async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
# X19 method, not sure compatibility
if not api_stats:
try:
@@ -370,13 +353,13 @@ class CGMiner(BaseMiner):
return round(expected_rate / 1000000, 2)
else:
return round(expected_rate, 2)
except (KeyError, IndexError):
except LookupError:
pass
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, api_stats: dict = None) -> Optional[int]:
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]:
if not api_stats:
try:
api_stats = await self.api.stats()

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

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

81
pyasic/miners/backends/epic.py
View File

@@ -14,12 +14,11 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
from typing import List, Optional, Tuple
from typing import List, Optional
from pyasic import MinerConfig
from pyasic.config import MinerConfig
from pyasic.data import Fan, HashBoard
from pyasic.data.error_codes import MinerErrorData, X19Error
from pyasic.config import MinerConfig, MiningModeConfig
from pyasic.errors import APIError
from pyasic.logger import logger
from pyasic.miners.base import (
@@ -34,47 +33,46 @@ from pyasic.web.epic import ePICWebAPI
EPIC_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac", [WebAPICommand("web_network", "network")]
"_get_mac", [WebAPICommand("web_network", "network")]
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction("get_api_ver"),
str(DataOptions.API_VERSION): DataFunction("_get_api_ver"),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [WebAPICommand("web_summary", "summary")]
"_get_fw_ver", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.HOSTNAME): DataFunction(
"get_hostname", [WebAPICommand("web_summary", "summary")]
"_get_hostname", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [WebAPICommand("web_summary", "summary")]
"_get_hashrate", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [WebAPICommand("web_summary", "summary")]
"_get_expected_hashrate", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards",
"_get_hashboards",
[
WebAPICommand("web_summary", "summary"),
WebAPICommand("web_hashrate", "hashrate"),
],
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction(
"get_wattage", [WebAPICommand("web_summary", "summary")]
"_get_wattage", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [WebAPICommand("web_summary", "summary")]
"_get_fans", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction(
"get_errors", [WebAPICommand("web_summary", "summary")]
"_get_errors", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.FAULT_LIGHT): DataFunction(
"get_fault_light", [WebAPICommand("web_summary", "summary")]
"_get_fault_light", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [WebAPICommand("web_summary", "summary")]
"_get_uptime", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -89,14 +87,10 @@ class ePIC(BaseMiner):
# static data
self.api_type = "ePIC"
self.fw_str = "ePIC"
# data gathering locations
self.data_locations = EPIC_DATA_LOC
async def get_model(self) -> Optional[str]:
if self.model is not None:
return self.model + " (ePIC)"
return "? (ePIC)"
async def get_config(self) -> MinerConfig:
summary = None
try:
@@ -150,7 +144,7 @@ class ePIC(BaseMiner):
pass
return False
async def get_mac(self, web_network: dict = None) -> str:
async def _get_mac(self, web_network: dict = None) -> str:
if not web_network:
web_network = await self.web.network()
if web_network:
@@ -161,7 +155,7 @@ class ePIC(BaseMiner):
except KeyError:
pass
async def get_hostname(self, web_summary: dict = None) -> str:
async def _get_hostname(self, web_summary: dict = None) -> str:
if not web_summary:
web_summary = await self.web.summary()
if web_summary:
@@ -171,7 +165,7 @@ class ePIC(BaseMiner):
except KeyError:
pass
async def get_wattage(self, web_summary: dict = None) -> Optional[int]:
async def _get_wattage(self, web_summary: dict = None) -> Optional[int]:
if not web_summary:
web_summary = await self.web.summary()
@@ -183,7 +177,7 @@ class ePIC(BaseMiner):
except KeyError:
pass
async def get_hashrate(self, web_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, web_summary: dict = None) -> Optional[float]:
# get hr from API
if not web_summary:
try:
@@ -202,7 +196,7 @@ class ePIC(BaseMiner):
logger.error(e)
pass
async def get_expected_hashrate(self, web_summary: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, web_summary: dict = None) -> Optional[float]:
# get hr from API
if not web_summary:
try:
@@ -222,11 +216,11 @@ class ePIC(BaseMiner):
hashrate += hb["Hashrate"][0] / ideal
return round(float(float(hashrate / 1000000)), 2)
except (IndexError, KeyError, ValueError, TypeError) as e:
except (LookupError, ValueError, TypeError) as e:
logger.error(e)
pass
async def get_fw_ver(self, web_summary: dict = None) -> Optional[str]:
async def _get_fw_ver(self, web_summary: dict = None) -> Optional[str]:
if not web_summary:
web_summary = await self.web.summary()
@@ -238,7 +232,7 @@ class ePIC(BaseMiner):
except KeyError:
pass
async def get_fans(self, web_summary: dict = None) -> List[Fan]:
async def _get_fans(self, web_summary: dict = None) -> List[Fan]:
if not web_summary:
try:
web_summary = await self.web.summary()
@@ -255,7 +249,7 @@ class ePIC(BaseMiner):
fans.append(Fan())
return fans
async def get_hashboards(
async def _get_hashboards(
self, web_summary: dict = None, web_hashrate: dict = None
) -> List[HashBoard]:
if not web_summary:
@@ -286,10 +280,10 @@ class ePIC(BaseMiner):
hb_list[hr["Index"]].temp = hb["Temperature"]
return hb_list
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, web_summary: dict = None) -> Optional[int]:
async def _get_uptime(self, web_summary: dict = None) -> Optional[int]:
if not web_summary:
web_summary = await self.web.summary()
if web_summary:
@@ -300,7 +294,7 @@ class ePIC(BaseMiner):
pass
return None
async def get_fault_light(self, web_summary: dict = None) -> bool:
async def _get_fault_light(self, web_summary: dict = None) -> bool:
if not web_summary:
web_summary = await self.web.summary()
if web_summary:
@@ -311,7 +305,7 @@ class ePIC(BaseMiner):
pass
return False
async def get_errors(self, web_summary: dict = None) -> List[MinerErrorData]:
async def _get_errors(self, web_summary: dict = None) -> List[MinerErrorData]:
if not web_summary:
web_summary = await self.web.summary()
errors = []
@@ -331,22 +325,19 @@ class ePIC(BaseMiner):
def fault_light_on(self) -> bool:
return False
def get_api_ver(self, *args, **kwargs) -> Optional[str]:
def _get_api_ver(self, *args, **kwargs) -> Optional[str]:
pass
def get_config(self) -> MinerConfig:
return self.config
def get_env_temp(self, *args, **kwargs) -> Optional[float]:
def _get_env_temp(self, *args, **kwargs) -> Optional[float]:
pass
def get_fan_psu(self, *args, **kwargs) -> Optional[int]:
def _get_fan_psu(self, *args, **kwargs) -> Optional[int]:
pass
def get_version(self, *args, **kwargs) -> Tuple[Optional[str], Optional[str]]:
pass
def get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
def _get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
pass
def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:

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

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

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

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

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

@@ -13,18 +13,12 @@
# See the License for the specific language governing permissions and -
# limitations under the License. -
# ------------------------------------------------------------------------------
import asyncio
import logging
from collections import namedtuple
from typing import List, Optional, Tuple, Union
import toml
from pyasic.API.bosminer import BOSMinerAPI
from pyasic.API.luxminer import LUXMinerAPI
from pyasic.config import MinerConfig
from pyasic.data import Fan, HashBoard
from pyasic.data.error_codes import BraiinsOSError, MinerErrorData
from pyasic.data.error_codes import MinerErrorData
from pyasic.errors import APIError
from pyasic.miners.base import (
BaseMiner,
@@ -32,42 +26,39 @@ from pyasic.miners.base import (
DataLocations,
DataOptions,
RPCAPICommand,
WebAPICommand,
)
from pyasic.web.bosminer import BOSMinerWebAPI
LUXMINER_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac", [RPCAPICommand("api_config", "config")]
"_get_mac", [RPCAPICommand("api_config", "config")]
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction("get_api_ver"),
str(DataOptions.FW_VERSION): DataFunction("get_fw_ver"),
str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
str(DataOptions.API_VERSION): DataFunction("_get_api_ver"),
str(DataOptions.FW_VERSION): DataFunction("_get_fw_ver"),
str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_stats", "stats")]
"_get_hashboards", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction(
"get_wattage", [RPCAPICommand("api_power", "power")]
"_get_wattage", [RPCAPICommand("api_power", "power")]
),
str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_fans", "fans")]
"_get_fans", [RPCAPICommand("api_fans", "fans")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction(
"get_uptime", [RPCAPICommand("api_stats", "stats")]
"_get_uptime", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
@@ -83,6 +74,7 @@ class LUXMiner(BaseMiner):
# static data
self.api_type = "LUXMiner"
self.fw_str = "LuxOS"
# data gathering locations
self.data_locations = LUXMINER_DATA_LOC
# autotuning/shutdown support
@@ -181,7 +173,7 @@ class LUXMiner(BaseMiner):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
async def get_mac(self, api_config: dict = None) -> Optional[str]:
async def _get_mac(self, api_config: dict = None) -> Optional[str]:
mac = None
if not api_config:
try:
@@ -197,24 +189,19 @@ class LUXMiner(BaseMiner):
return mac
async def get_model(self) -> Optional[str]:
if self.model is not None:
return self.model + " (LuxOS)"
return "? (LuxOS)"
async def get_version(self) -> Tuple[Optional[str], Optional[str]]:
pass
async def get_api_ver(self) -> Optional[str]:
async def _get_api_ver(self) -> Optional[str]:
pass
async def get_fw_ver(self) -> Optional[str]:
async def _get_fw_ver(self) -> Optional[str]:
pass
async def get_hostname(self) -> Union[str, None]:
async def _get_hostname(self) -> Union[str, None]:
pass
async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
if not api_summary:
try:
api_summary = await self.api.summary()
@@ -224,10 +211,10 @@ class LUXMiner(BaseMiner):
if api_summary:
try:
return round(float(api_summary["SUMMARY"][0]["GHS 5s"] / 1000), 2)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
hashboards = []
if not api_stats:
@@ -276,15 +263,15 @@ class LUXMiner(BaseMiner):
if (not chips) or (not chips > 0):
hashboard.missing = True
hashboards.append(hashboard)
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
return hashboards
async def get_env_temp(self) -> Optional[float]:
async def _get_env_temp(self) -> Optional[float]:
return None
async def get_wattage(self, api_power: dict) -> Optional[int]:
async def _get_wattage(self, api_power: dict) -> Optional[int]:
if not api_power:
try:
api_power = await self.api.power()
@@ -294,13 +281,13 @@ class LUXMiner(BaseMiner):
if api_power:
try:
return api_power["POWER"][0]["Watts"]
except (IndexError, KeyError, ValueError, TypeError):
except (LookupError, ValueError, TypeError):
pass
async def get_wattage_limit(self) -> Optional[int]:
async def _get_wattage_limit(self) -> Optional[int]:
return None
async def get_fans(self, api_fans: dict = None) -> List[Fan]:
async def _get_fans(self, api_fans: dict = None) -> List[Fan]:
if not api_fans:
try:
api_fans = await self.api.fans()
@@ -310,23 +297,23 @@ class LUXMiner(BaseMiner):
fans = []
if api_fans:
for fan in range(self.fan_count):
for fan in range(self.expected_fans):
try:
fans.append(Fan(api_fans["FANS"][0]["RPM"]))
except (IndexError, KeyError, ValueError, TypeError):
fans.append(Fan(api_fans["FANS"][fan]["RPM"]))
except (LookupError, ValueError, TypeError):
fans.append(Fan())
return fans
async def get_fan_psu(self) -> Optional[int]:
async def _get_fan_psu(self) -> Optional[int]:
return None
async def get_errors(self) -> List[MinerErrorData]:
async def _get_errors(self) -> List[MinerErrorData]:
pass
async def get_fault_light(self) -> bool:
async def _get_fault_light(self) -> bool:
pass
async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
if not api_stats:
try:
api_stats = await self.api.stats()
@@ -346,13 +333,13 @@ class LUXMiner(BaseMiner):
return round(expected_rate / 1000000, 2)
else:
return round(expected_rate, 2)
except (KeyError, IndexError):
except LookupError:
pass
async def is_mining(self) -> Optional[bool]:
async def _is_mining(self) -> Optional[bool]:
pass
async def get_uptime(self, api_stats: dict = None) -> Optional[int]:
async def _get_uptime(self, api_stats: dict = None) -> Optional[int]:
if not api_stats:
try:
api_stats = await self.api.stats()

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

@@ -32,42 +32,41 @@ from pyasic.web.vnish import VNishWebAPI
VNISH_DATA_LOC = DataLocations(
**{
str(DataOptions.MAC): DataFunction(
"get_mac", [WebAPICommand("web_summary", "summary")]
"_get_mac", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.MODEL): DataFunction("get_model"),
str(DataOptions.API_VERSION): DataFunction(
"get_api_ver", [RPCAPICommand("api_version", "version")]
"_get_api_ver", [RPCAPICommand("api_version", "version")]
),
str(DataOptions.FW_VERSION): DataFunction(
"get_fw_ver", [WebAPICommand("web_summary", "summary")]
"_get_fw_ver", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.HOSTNAME): DataFunction(
"get_hostname", [WebAPICommand("web_summary", "summary")]
"_get_hostname", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.HASHRATE): DataFunction(
"get_hashrate", [RPCAPICommand("api_summary", "summary")]
"_get_hashrate", [RPCAPICommand("api_summary", "summary")]
),
str(DataOptions.EXPECTED_HASHRATE): DataFunction(
"get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
"_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.HASHBOARDS): DataFunction(
"get_hashboards", [RPCAPICommand("api_stats", "stats")]
"_get_hashboards", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
str(DataOptions.WATTAGE): DataFunction(
"get_wattage", [WebAPICommand("web_summary", "summary")]
"_get_wattage", [WebAPICommand("web_summary", "summary")]
),
str(DataOptions.WATTAGE_LIMIT): DataFunction(
"get_wattage_limit", [WebAPICommand("web_settings", "settings")]
"_get_wattage_limit", [WebAPICommand("web_settings", "settings")]
),
str(DataOptions.FANS): DataFunction(
"get_fans", [RPCAPICommand("api_stats", "stats")]
"_get_fans", [RPCAPICommand("api_stats", "stats")]
),
str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("is_mining"),
str(DataOptions.UPTIME): DataFunction("get_uptime"),
str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
str(DataOptions.ERRORS): DataFunction("_get_errors"),
str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
str(DataOptions.IS_MINING): DataFunction("_is_mining"),
str(DataOptions.UPTIME): DataFunction("_get_uptime"),
str(DataOptions.CONFIG): DataFunction("get_config"),
}
)
@@ -81,14 +80,10 @@ class VNish(BMMiner):
# static data
self.api_type = "VNish"
self.fw_str = "VNish"
# data gathering locations
self.data_locations = VNISH_DATA_LOC
async def get_model(self) -> Optional[str]:
if self.model is not None:
return self.model + " (VNish)"
return "? (VNish)"
async def restart_backend(self) -> bool:
data = await self.web.restart_vnish()
if data:
@@ -125,7 +120,7 @@ class VNish(BMMiner):
pass
return False
async def get_mac(self, web_summary: dict = None) -> str:
async def _get_mac(self, web_summary: dict = None) -> str:
if not web_summary:
web_info = await self.web.info()
@@ -143,7 +138,7 @@ class VNish(BMMiner):
except KeyError:
pass
async def get_hostname(self, web_summary: dict = None) -> str:
async def _get_hostname(self, web_summary: dict = None) -> str:
if not web_summary:
web_info = await self.web.info()
@@ -161,7 +156,7 @@ class VNish(BMMiner):
except KeyError:
pass
async def get_wattage(self, web_summary: dict = None) -> Optional[int]:
async def _get_wattage(self, web_summary: dict = None) -> Optional[int]:
if not web_summary:
web_summary = await self.web.summary()
@@ -173,7 +168,7 @@ class VNish(BMMiner):
except KeyError:
pass
async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
# get hr from API
if not api_summary:
try:
@@ -186,11 +181,11 @@ class VNish(BMMiner):
return round(
float(float(api_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2
)
except (IndexError, KeyError, ValueError, TypeError) as e:
except (LookupError, ValueError, TypeError) as e:
logger.error(e)
pass
async def get_wattage_limit(self, web_settings: dict = None) -> Optional[int]:
async def _get_wattage_limit(self, web_settings: dict = None) -> Optional[int]:
if not web_settings:
web_settings = await self.web.summary()
@@ -203,7 +198,7 @@ class VNish(BMMiner):
except (KeyError, TypeError):
pass
async def get_fw_ver(self, web_summary: dict = None) -> Optional[str]:
async def _get_fw_ver(self, web_summary: dict = None) -> Optional[str]:
if not web_summary:
web_summary = await self.web.summary()
@@ -215,10 +210,10 @@ class VNish(BMMiner):
except KeyError:
pass
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
return None
async def get_uptime(self, *args, **kwargs) -> Optional[int]:
async def _get_uptime(self, *args, **kwargs) -> Optional[int]:
return None
async def get_config(self) -> MinerConfig:

163
pyasic/miners/base.py
View File

@@ -31,7 +31,6 @@ from pyasic.logger import logger
class DataOptions(Enum):
MAC = "mac"
MODEL = "model"
API_VERSION = "api_ver"
FW_VERSION = "fw_ver"
HOSTNAME = "hostname"
@@ -106,11 +105,12 @@ class BaseMiner(ABC):
self.api_type = None
# type
self.make = None
self.model = None
self.raw_model = None
self.fw_str = None
# physical attributes
self.expected_hashboards = 3
self.expected_chips = 0
self.fan_count = 2
self.expected_fans = 2
# data gathering locations
self.data_locations: DataLocations = None
# autotuning/shutdown support
@@ -140,6 +140,13 @@ class BaseMiner(ABC):
def __eq__(self, other):
return ipaddress.ip_address(self.ip) == ipaddress.ip_address(other.ip)
@property
def model(self):
model_data = [self.raw_model]
if self.fw_str is not None:
model_data.append(f"({self.fw_str})")
return " ".join(model_data)
@property
def pwd(self): # noqa - Skip PyCharm inspection
data = []
@@ -309,14 +316,13 @@ class BaseMiner(ABC):
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
##################################################
@abstractmethod
async def get_mac(self, *args, **kwargs) -> Optional[str]:
async def get_mac(self) -> Optional[str]:
"""Get the MAC address of the miner and return it as a string.
Returns:
A string representing the MAC address of the miner.
"""
pass
return await self._get_mac()
async def get_model(self) -> Optional[str]:
"""Get the model of the miner and return it as a string.
@@ -326,148 +332,198 @@ class BaseMiner(ABC):
"""
return self.model
@abstractmethod
async def get_api_ver(self, *args, **kwargs) -> Optional[str]:
async def get_api_ver(self) -> Optional[str]:
"""Get the API version of the miner and is as a string.
Returns:
API version as a string.
"""
pass
return await self._get_api_ver()
@abstractmethod
async def get_fw_ver(self, *args, **kwargs) -> Optional[str]:
async def get_fw_ver(self) -> Optional[str]:
"""Get the firmware version of the miner and is as a string.
Returns:
Firmware version as a string.
"""
pass
return await self._get_fw_ver()
@abstractmethod
async def get_version(self, *args, **kwargs) -> Tuple[Optional[str], Optional[str]]:
async def get_version(self) -> Tuple[Optional[str], Optional[str]]:
"""Get the API version and firmware version of the miner and return them as strings.
Returns:
A tuple of (API version, firmware version) as strings.
"""
pass
api_ver = await self.get_api_ver()
fw_ver = await self.get_fw_ver()
return api_ver, fw_ver
@abstractmethod
async def get_hostname(self, *args, **kwargs) -> Optional[str]:
async def get_hostname(self) -> Optional[str]:
"""Get the hostname of the miner and return it as a string.
Returns:
A string representing the hostname of the miner.
"""
pass
return await self._get_hostname()
@abstractmethod
async def get_hashrate(self, *args, **kwargs) -> Optional[float]:
async def get_hashrate(self) -> Optional[float]:
"""Get the hashrate of the miner and return it as a float in TH/s.
Returns:
Hashrate of the miner in TH/s as a float.
"""
pass
return await self._get_hashrate()
@abstractmethod
async def get_hashboards(self, *args, **kwargs) -> List[HashBoard]:
async def get_hashboards(self) -> List[HashBoard]:
"""Get hashboard data from the miner in the form of [`HashBoard`][pyasic.data.HashBoard].
Returns:
A [`HashBoard`][pyasic.data.HashBoard] instance containing hashboard data from the miner.
"""
pass
return await self._get_hashboards()
@abstractmethod
async def get_env_temp(self, *args, **kwargs) -> Optional[float]:
async def get_env_temp(self) -> Optional[float]:
"""Get environment temp from the miner as a float.
Returns:
Environment temp of the miner as a float.
"""
pass
return await self._get_env_temp()
@abstractmethod
async def get_wattage(self, *args, **kwargs) -> Optional[int]:
async def get_wattage(self) -> Optional[int]:
"""Get wattage from the miner as an int.
Returns:
Wattage of the miner as an int.
"""
pass
return await self._get_wattage()
@abstractmethod
async def get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
async def get_wattage_limit(self) -> Optional[int]:
"""Get wattage limit from the miner as an int.
Returns:
Wattage limit of the miner as an int.
"""
pass
return await self._get_wattage_limit()
@abstractmethod
async def get_fans(self, *args, **kwargs) -> List[Fan]:
async def get_fans(self) -> List[Fan]:
"""Get fan data from the miner in the form [fan_1, fan_2, fan_3, fan_4].
Returns:
A list of fan data.
"""
pass
return await self._get_fans()
@abstractmethod
async def get_fan_psu(self, *args, **kwargs) -> Optional[int]:
async def get_fan_psu(self) -> Optional[int]:
"""Get PSU fan speed from the miner.
Returns:
PSU fan speed.
"""
pass
return await self._get_fan_psu()
@abstractmethod
async def get_errors(self, *args, **kwargs) -> List[MinerErrorData]:
async def get_errors(self) -> List[MinerErrorData]:
"""Get a list of the errors the miner is experiencing.
Returns:
A list of error classes representing different errors.
"""
pass
return await self._get_errors()
@abstractmethod
async def get_fault_light(self, *args, **kwargs) -> bool:
async def get_fault_light(self) -> bool:
"""Check the status of the fault light and return on or off as a boolean.
Returns:
A boolean value where `True` represents on and `False` represents off.
"""
pass
return await self._get_fault_light()
@abstractmethod
async def get_expected_hashrate(self, *args, **kwargs) -> Optional[float]:
async def get_expected_hashrate(self) -> Optional[float]:
"""Get the nominal hashrate from factory if available.
Returns:
A float value of nominal hashrate in TH/s.
"""
pass
return await self._get_expected_hashrate()
@abstractmethod
async def is_mining(self, *args, **kwargs) -> Optional[bool]:
async def is_mining(self) -> Optional[bool]:
"""Check whether the miner is mining.
Returns:
A boolean value representing if the miner is mining.
"""
pass
return await self._is_mining()
@abstractmethod
async def get_uptime(self, *args, **kwargs) -> Optional[int]:
async def get_uptime(self) -> Optional[int]:
"""Get the uptime of the miner in seconds.
Returns:
The uptime of the miner in seconds.
"""
return await self._get_uptime()
@abstractmethod
async def _get_mac(self, *args, **kwargs) -> Optional[str]:
pass
@abstractmethod
async def _get_api_ver(self, *args, **kwargs) -> Optional[str]:
pass
@abstractmethod
async def _get_fw_ver(self, *args, **kwargs) -> Optional[str]:
pass
@abstractmethod
async def _get_hostname(self, *args, **kwargs) -> Optional[str]:
pass
@abstractmethod
async def _get_hashrate(self, *args, **kwargs) -> Optional[float]:
pass
@abstractmethod
async def _get_hashboards(self, *args, **kwargs) -> List[HashBoard]:
pass
@abstractmethod
async def _get_env_temp(self, *args, **kwargs) -> Optional[float]:
pass
@abstractmethod
async def _get_wattage(self, *args, **kwargs) -> Optional[int]:
pass
@abstractmethod
async def _get_wattage_limit(self, *args, **kwargs) -> Optional[int]:
pass
@abstractmethod
async def _get_fans(self, *args, **kwargs) -> List[Fan]:
pass
@abstractmethod
async def _get_fan_psu(self, *args, **kwargs) -> Optional[int]:
pass
@abstractmethod
async def _get_errors(self, *args, **kwargs) -> List[MinerErrorData]:
pass
@abstractmethod
async def _get_fault_light(self, *args, **kwargs) -> bool:
pass
@abstractmethod
async def _get_expected_hashrate(self, *args, **kwargs) -> Optional[float]:
pass
@abstractmethod
async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
pass
@abstractmethod
async def _get_uptime(self, *args, **kwargs) -> Optional[int]:
pass
async def _get_data(
@@ -571,6 +627,7 @@ class BaseMiner(ABC):
data = MinerData(
ip=str(self.ip),
make=self.make,
model=self.model,
expected_chips=self.expected_chips * self.expected_hashboards,
expected_hashboards=self.expected_hashboards,
hashboards=[

2
pyasic/miners/types/antminer/X15/Z15.py
View File

@@ -21,6 +21,6 @@ class Z15(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Z15"
self.raw_model = "Z15"
self.expected_chips = 3
self.fan_count = 2

8
pyasic/miners/types/antminer/X17/S17.py
View File

@@ -21,7 +21,7 @@ class S17(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S17"
self.raw_model = "S17"
self.expected_chips = 48
self.fan_count = 4
@@ -29,7 +29,7 @@ class S17(AntMiner): # noqa - ignore ABC method implementation
class S17Plus(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.model = "S17+"
self.raw_model = "S17+"
self.expected_chips = 65
self.fan_count = 4
@@ -38,7 +38,7 @@ class S17Pro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S17 Pro"
self.raw_model = "S17 Pro"
self.expected_chips = 48
self.fan_count = 4
@@ -47,6 +47,6 @@ class S17e(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S17e"
self.raw_model = "S17e"
self.expected_chips = 135
self.fan_count = 4

6
pyasic/miners/types/antminer/X17/T17.py
View File

@@ -21,7 +21,7 @@ class T17(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "T17"
self.raw_model = "T17"
self.expected_chips = 30
self.fan_count = 4
@@ -30,7 +30,7 @@ class T17Plus(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "T17+"
self.raw_model = "T17+"
self.expected_chips = 44
self.fan_count = 4
@@ -39,6 +39,6 @@ class T17e(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "T17e"
self.raw_model = "T17e"
self.expected_chips = 78
self.fan_count = 4

34
pyasic/miners/types/antminer/X19/S19.py
View File

@@ -21,7 +21,7 @@ class S19(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19"
self.raw_model = "S19"
self.expected_chips = 76
self.fan_count = 4
@@ -30,7 +30,7 @@ class S19NoPIC(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19 No PIC"
self.raw_model = "S19 No PIC"
self.expected_chips = 88
self.fan_count = 4
@@ -39,7 +39,7 @@ class S19Pro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19 Pro"
self.raw_model = "S19 Pro"
self.expected_chips = 114
self.fan_count = 4
@@ -48,7 +48,7 @@ class S19i(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19i"
self.raw_model = "S19i"
self.expected_chips = 80
self.fan_count = 4
@@ -57,7 +57,7 @@ class S19Plus(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19+"
self.raw_model = "S19+"
self.expected_chips = 80
self.fan_count = 4
@@ -66,7 +66,7 @@ class S19ProPlus(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19 Pro+"
self.raw_model = "S19 Pro+"
self.expected_chips = 120
self.fan_count = 4
@@ -75,7 +75,7 @@ class S19XP(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19 XP"
self.raw_model = "S19 XP"
self.expected_chips = 110
self.fan_count = 4
@@ -84,7 +84,7 @@ class S19a(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19a"
self.raw_model = "S19a"
self.expected_chips = 72
self.fan_count = 4
@@ -93,7 +93,7 @@ class S19aPro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19a Pro"
self.raw_model = "S19a Pro"
self.expected_chips = 100
self.fan_count = 4
@@ -102,7 +102,7 @@ class S19j(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19j"
self.raw_model = "S19j"
self.expected_chips = 114
self.fan_count = 4
@@ -111,7 +111,7 @@ class S19jNoPIC(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19j No PIC"
self.raw_model = "S19j No PIC"
self.expected_chips = 88
self.fan_count = 4
@@ -120,7 +120,7 @@ class S19jPro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19j Pro"
self.raw_model = "S19j Pro"
self.expected_chips = 126
self.fan_count = 4
@@ -129,7 +129,7 @@ class S19jProPlus(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19j Pro+"
self.raw_model = "S19j Pro+"
self.expected_chips = 120
self.fan_count = 4
@@ -138,7 +138,7 @@ class S19kPro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19k Pro"
self.raw_model = "S19k Pro"
self.expected_chips = 77
self.fan_count = 4
@@ -147,7 +147,7 @@ class S19L(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19L"
self.raw_model = "S19L"
self.expected_chips = 76
self.fan_count = 4
@@ -156,7 +156,7 @@ class S19kProNoPIC(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19k Pro No PIC"
self.raw_model = "S19k Pro No PIC"
self.expected_chips = 77
self.fan_count = 4
@@ -165,7 +165,7 @@ class S19ProHydro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S19 Pro Hydro"
self.raw_model = "S19 Pro Hydro"
self.expected_chips = 180
self.expected_hashboards = 4
self.fan_count = 0

2
pyasic/miners/types/antminer/X19/T19.py
View File

@@ -21,6 +21,6 @@ class T19(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "T19"
self.raw_model = "T19"
self.expected_chips = 76
self.fan_count = 4

2
pyasic/miners/types/antminer/X3/D3.py
View File

@@ -21,7 +21,7 @@ class D3(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "D3"
self.raw_model = "D3"
self.expected_chips = 60
self.expected_hashboards = 3
self.fan_count = 2

2
pyasic/miners/types/antminer/X3/HS3.py
View File

@@ -21,7 +21,7 @@ class HS3(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "HS3"
self.raw_model = "HS3"
self.expected_chips = 92
self.expected_hashboards = 3
self.fan_count = 2

2
pyasic/miners/types/antminer/X3/L3.py
View File

@@ -20,6 +20,6 @@ class L3Plus(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "L3+"
self.raw_model = "L3+"
self.expected_chips = 72
self.fan_count = 2

2
pyasic/miners/types/antminer/X5/DR5.py
View File

@@ -21,7 +21,7 @@ class DR5(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "DR5"
self.raw_model = "DR5"
self.expected_chips = 72
self.expected_hashboards = 3
self.fan_count = 2

2
pyasic/miners/types/antminer/X7/L7.py
View File

@@ -20,6 +20,6 @@ class L7(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "L7"
self.raw_model = "L7"
self.expected_chips = 120
self.fan_count = 4

2
pyasic/miners/types/antminer/X9/E9.py
View File

@@ -21,7 +21,7 @@ class E9Pro(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "E9Pro"
self.raw_model = "E9Pro"
self.expected_chips = 8
self.expected_hashboards = 2
self.fan_count = 4

6
pyasic/miners/types/antminer/X9/S9.py
View File

@@ -21,7 +21,7 @@ class S9(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S9"
self.raw_model = "S9"
self.expected_chips = 63
self.fan_count = 2
@@ -30,7 +30,7 @@ class S9i(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S9i"
self.raw_model = "S9i"
self.expected_chips = 63
self.fan_count = 2
@@ -39,6 +39,6 @@ class S9j(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "S9j"
self.raw_model = "S9j"
self.expected_chips = 63
self.fan_count = 2

2
pyasic/miners/types/antminer/X9/T9.py
View File

@@ -21,6 +21,6 @@ class T9(AntMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "T9"
self.raw_model = "T9"
self.expected_chips = 54
self.fan_count = 2

2
pyasic/miners/types/avalonminer/A10X/A1026.py
View File

@@ -21,6 +21,6 @@ class Avalon1026(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 1026"
self.raw_model = "Avalon 1026"
self.expected_chips = 80
self.fan_count = 2

2
pyasic/miners/types/avalonminer/A10X/A1047.py
View File

@@ -21,6 +21,6 @@ class Avalon1047(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 1047"
self.raw_model = "Avalon 1047"
self.expected_chips = 80
self.fan_count = 2

2
pyasic/miners/types/avalonminer/A10X/A1066.py
View File

@@ -21,6 +21,6 @@ class Avalon1066(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 1066"
self.raw_model = "Avalon 1066"
self.expected_chips = 114
self.fan_count = 4

3
pyasic/miners/types/avalonminer/A11X/A1166.py
View File

@@ -13,7 +13,6 @@
# See the License for the specific language governing permissions and -
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import AvalonMiner
@@ -22,6 +21,6 @@ class Avalon1166Pro(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 1166 Pro"
self.raw_model = "Avalon 1166 Pro"
self.expected_chips = 120
self.fan_count = 4

3
pyasic/miners/types/avalonminer/A12X/A1246.py
View File

@@ -13,7 +13,6 @@
# See the License for the specific language governing permissions and -
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import AvalonMiner
@@ -22,6 +21,6 @@ class Avalon1246(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 1246"
self.raw_model = "Avalon 1246"
self.expected_chips = 120
self.fan_count = 4

2
pyasic/miners/types/avalonminer/A7X/A721.py
View File

@@ -21,7 +21,7 @@ class Avalon721(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 721"
self.raw_model = "Avalon 721"
self.expected_hashboards = 4
self.expected_chips = 18
self.fan_count = 1

2
pyasic/miners/types/avalonminer/A7X/A741.py
View File

@@ -21,7 +21,7 @@ class Avalon741(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 741"
self.raw_model = "Avalon 741"
self.expected_hashboards = 4
self.expected_chips = 22
self.fan_count = 1

2
pyasic/miners/types/avalonminer/A7X/A761.py
View File

@@ -21,7 +21,7 @@ class Avalon761(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 761"
self.raw_model = "Avalon 761"
self.expected_hashboards = 4
self.expected_chips = 18
self.fan_count = 1

2
pyasic/miners/types/avalonminer/A8X/A821.py
View File

@@ -21,7 +21,7 @@ class Avalon821(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 821"
self.raw_model = "Avalon 821"
self.expected_hashboards = 4
self.expected_chips = 26
self.fan_count = 1

2
pyasic/miners/types/avalonminer/A8X/A841.py
View File

@@ -21,7 +21,7 @@ class Avalon841(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 841"
self.raw_model = "Avalon 841"
self.expected_hashboards = 4
self.expected_chips = 26
self.fan_count = 1

2
pyasic/miners/types/avalonminer/A8X/A851.py
View File

@@ -21,7 +21,7 @@ class Avalon851(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 851"
self.raw_model = "Avalon 851"
self.expected_hashboards = 4
self.expected_chips = 26
self.fan_count = 1

2
pyasic/miners/types/avalonminer/A9X/A921.py
View File

@@ -21,7 +21,7 @@ class Avalon921(AvalonMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "Avalon 921"
self.raw_model = "Avalon 921"
self.expected_hashboards = 4
self.expected_chips = 26
self.fan_count = 1

2
pyasic/miners/types/goldshell/X5/CK5.py
View File

@@ -20,7 +20,7 @@ class CK5(GoldshellMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "CK5"
self.raw_model = "CK5"
self.expected_hashboards = 4
self.expected_chips = 46
self.fan_count = 4

2
pyasic/miners/types/goldshell/X5/HS5.py
View File

@@ -20,7 +20,7 @@ class HS5(GoldshellMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "HS5"
self.raw_model = "HS5"
self.expected_hashboards = 4
self.expected_chips = 46
self.fan_count = 4

2
pyasic/miners/types/goldshell/X5/KD5.py
View File

@@ -20,7 +20,7 @@ class KD5(GoldshellMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "KD5"
self.raw_model = "KD5"
self.expected_hashboards = 4
self.expected_chips = 46
self.fan_count = 4

2
pyasic/miners/types/goldshell/XMax/KDMax.py
View File

@@ -20,7 +20,7 @@ class KDMax(GoldshellMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "KD Max"
self.raw_model = "KD Max"
self.expected_hashboards = 3
self.expected_chips = 84
self.fan_count = 4

2
pyasic/miners/types/innosilicon/A10X/A10X.py
View File

@@ -20,4 +20,4 @@ class A10X(InnosiliconMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
super().__init__(ip, api_ver)
self.ip = ip
self.model = "A10X"
self.raw_model = "A10X"

2
pyasic/miners/types/innosilicon/T3X/T3H.py
View File

@@ -21,6 +21,6 @@ class T3HPlus(InnosiliconMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
super().__init__(ip, api_ver)
self.ip = ip
self.model = "T3H+"
self.raw_model = "T3H+"
self.expected_chips = 114
self.fan_count = 4

2
pyasic/miners/types/whatsminer/M2X/M20.py
View File

@@ -21,6 +21,6 @@ class M20V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20 V10"
self.raw_model = "M20 V10"
self.expected_chips = 70
self.fan_count = 2

4
pyasic/miners/types/whatsminer/M2X/M20P.py
View File

@@ -21,7 +21,7 @@ class M20PV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20P V10"
self.raw_model = "M20P V10"
self.expected_chips = 156
self.fan_count = 2
@@ -30,6 +30,6 @@ class M20PV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20P V30"
self.raw_model = "M20P V30"
self.expected_chips = 148
self.fan_count = 2

8
pyasic/miners/types/whatsminer/M2X/M20S.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M20SV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20S V10"
self.raw_model = "M20S V10"
self.expected_chips = 105
self.fan_count = 2
@@ -32,7 +30,7 @@ class M20SV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20S V20"
self.raw_model = "M20S V20"
self.expected_chips = 111
self.fan_count = 2
@@ -41,6 +39,6 @@ class M20SV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20S V30"
self.raw_model = "M20S V30"
self.expected_chips = 140
self.fan_count = 2

2
pyasic/miners/types/whatsminer/M2X/M20S_Plus.py
View File

@@ -23,7 +23,7 @@ class M20SPlusV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M20S+ V30"
self.raw_model = "M20S+ V30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M20S+ V30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

4
pyasic/miners/types/whatsminer/M2X/M21.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,6 +21,6 @@ class M21V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M21 V10"
self.raw_model = "M21 V10"
self.expected_chips = 33
self.fan_count = 2

8
pyasic/miners/types/whatsminer/M2X/M21S.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M21SV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M21S V20"
self.raw_model = "M21S V20"
self.expected_chips = 66
self.fan_count = 2
@@ -32,7 +30,7 @@ class M21SV60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M21S V60"
self.raw_model = "M21S V60"
self.expected_chips = 105
self.fan_count = 2
@@ -41,6 +39,6 @@ class M21SV70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M21S V70"
self.raw_model = "M21S V70"
self.expected_chips = 111
self.fan_count = 2

2
pyasic/miners/types/whatsminer/M2X/M21S_Plus.py
View File

@@ -23,7 +23,7 @@ class M21SPlusV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M21S+ V20"
self.raw_model = "M21S+ V20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M21S+ V20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

4
pyasic/miners/types/whatsminer/M2X/M29.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,6 +21,6 @@ class M29V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M29 V10"
self.raw_model = "M29 V10"
self.expected_chips = 50
self.fan_count = 2

6
pyasic/miners/types/whatsminer/M3X/M30.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M30V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30 V10"
self.raw_model = "M30 V10"
self.expected_chips = 105
self.fan_count = 2
@@ -32,6 +30,6 @@ class M30V20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30 V20"
self.raw_model = "M30 V20"
self.expected_chips = 111
self.fan_count = 2

4
pyasic/miners/types/whatsminer/M3X/M30K.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M30KV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30K V10"
self.raw_model = "M30K V10"
self.expected_hashboards = 4
self.expected_chips = 240
self.fan_count = 2

4
pyasic/miners/types/whatsminer/M3X/M30L.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M30LV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30L V10"
self.raw_model = "M30L V10"
self.board_num = 4
self.expected_chips = 144
self.fan_count = 2

58
pyasic/miners/types/whatsminer/M3X/M30S.py
View File

@@ -23,7 +23,7 @@ class M30SV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V10"
self.raw_model = "M30S V10"
self.expected_chips = 148
self.fan_count = 2
@@ -32,7 +32,7 @@ class M30SV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V20"
self.raw_model = "M30S V20"
self.expected_chips = 156
self.fan_count = 2
@@ -41,7 +41,7 @@ class M30SV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V30"
self.raw_model = "M30S V30"
self.expected_chips = 164
self.fan_count = 2
@@ -50,7 +50,7 @@ class M30SV40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V40"
self.raw_model = "M30S V40"
self.expected_chips = 172
self.fan_count = 2
@@ -59,7 +59,7 @@ class M30SV50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V50"
self.raw_model = "M30S V50"
self.expected_chips = 156
self.fan_count = 2
@@ -68,7 +68,7 @@ class M30SV60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V60"
self.raw_model = "M30S V60"
self.expected_chips = 164
self.fan_count = 2
@@ -77,7 +77,7 @@ class M30SV70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V70"
self.raw_model = "M30S V70"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30SV70, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -89,7 +89,7 @@ class M30SV80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S V80"
self.raw_model = "M30S V80"
self.expected_chips = 129
self.fan_count = 2
@@ -98,7 +98,7 @@ class M30SVE10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE10"
self.raw_model = "M30S VE10"
self.expected_chips = 105
self.fan_count = 2
@@ -107,7 +107,7 @@ class M30SVE20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE20"
self.raw_model = "M30S VE20"
self.expected_chips = 111
self.fan_count = 2
@@ -116,7 +116,7 @@ class M30SVE30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE30"
self.raw_model = "M30S VE30"
self.expected_chips = 117
self.fan_count = 2
@@ -125,7 +125,7 @@ class M30SVE40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE40"
self.raw_model = "M30S VE40"
self.expected_chips = 123
self.fan_count = 2
@@ -134,7 +134,7 @@ class M30SVE50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE50"
self.raw_model = "M30S VE50"
self.expected_chips = 129
self.fan_count = 2
@@ -143,7 +143,7 @@ class M30SVE60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE60"
self.raw_model = "M30S VE60"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30SVE60, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -155,7 +155,7 @@ class M30SVE70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VE70"
self.raw_model = "M30S VE70"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30SVE70, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -167,7 +167,7 @@ class M30SVF10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VF10"
self.raw_model = "M30S VF10"
self.expected_chips = 70
self.fan_count = 2
@@ -176,7 +176,7 @@ class M30SVF20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VF20"
self.raw_model = "M30S VF20"
self.expected_chips = 74
self.fan_count = 2
@@ -185,7 +185,7 @@ class M30SVF30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VF30"
self.raw_model = "M30S VF30"
self.expected_chips = 78
self.fan_count = 2
@@ -194,7 +194,7 @@ class M30SVG10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VG10"
self.raw_model = "M30S VG10"
self.expected_chips = 66
self.fan_count = 2
@@ -203,7 +203,7 @@ class M30SVG20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VG20"
self.raw_model = "M30S VG20"
self.expected_chips = 70
self.fan_count = 2
@@ -212,7 +212,7 @@ class M30SVG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VG30"
self.raw_model = "M30S VG30"
self.expected_chips = 74
self.fan_count = 2
@@ -221,7 +221,7 @@ class M30SVG40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VG40"
self.raw_model = "M30S VG40"
self.expected_chips = 78
self.fan_count = 2
@@ -230,7 +230,7 @@ class M30SVH10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VH10"
self.raw_model = "M30S VH10"
self.expected_chips = 64
self.fan_count = 2
@@ -239,7 +239,7 @@ class M30SVH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VH20"
self.raw_model = "M30S VH20"
self.expected_chips = 66
self.fan_count = 2
@@ -248,7 +248,7 @@ class M30SVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VH30"
self.raw_model = "M30S VH30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30SVH30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -260,7 +260,7 @@ class M30SVH40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VH40"
self.raw_model = "M30S VH40"
self.expected_chips = 64
self.fan_count = 2
@@ -269,7 +269,7 @@ class M30SVH50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VH50"
self.raw_model = "M30S VH50"
self.expected_chips = 66
self.fan_count = 2
@@ -278,7 +278,7 @@ class M30SVH60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VH60"
self.raw_model = "M30S VH60"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30SVH60, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -290,6 +290,6 @@ class M30SVI20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S VI20"
self.raw_model = "M30S VI20"
self.expected_chips = 70
self.fan_count = 2

62
pyasic/miners/types/whatsminer/M3X/M30S_Plus.py
View File

@@ -23,7 +23,7 @@ class M30SPlusV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V10"
self.raw_model = "M30S+ V10"
self.expected_chips = 215
self.fan_count = 2
@@ -32,7 +32,7 @@ class M30SPlusV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V20"
self.raw_model = "M30S+ V20"
self.expected_chips = 255
self.fan_count = 2
@@ -41,7 +41,7 @@ class M30SPlusV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V30"
self.raw_model = "M30S+ V30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ V30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -53,7 +53,7 @@ class M30SPlusV40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V40"
self.raw_model = "M30S+ V40"
self.expected_chips = 235
self.fan_count = 2
@@ -62,7 +62,7 @@ class M30SPlusV50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V50"
self.raw_model = "M30S+ V50"
self.expected_chips = 225
self.fan_count = 2
@@ -71,7 +71,7 @@ class M30SPlusV60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V60"
self.raw_model = "M30S+ V60"
self.expected_chips = 245
self.fan_count = 2
@@ -80,7 +80,7 @@ class M30SPlusV70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V70"
self.raw_model = "M30S+ V70"
self.expected_chips = 235
self.fan_count = 2
@@ -89,7 +89,7 @@ class M30SPlusV80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V80"
self.raw_model = "M30S+ V80"
self.expected_chips = 245
self.fan_count = 2
@@ -98,7 +98,7 @@ class M30SPlusV90(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V90"
self.raw_model = "M30S+ V90"
self.expected_chips = 225
self.fan_count = 2
@@ -107,7 +107,7 @@ class M30SPlusV100(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ V100"
self.raw_model = "M30S+ V100"
self.expected_chips = 215
self.fan_count = 2
@@ -116,7 +116,7 @@ class M30SPlusVE30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE30"
self.raw_model = "M30S+ VE30"
self.expected_chips = 148
self.fan_count = 2
@@ -125,7 +125,7 @@ class M30SPlusVE40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE40"
self.raw_model = "M30S+ VE40"
self.expected_chips = 156
self.fan_count = 2
@@ -134,7 +134,7 @@ class M30SPlusVE50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE50"
self.raw_model = "M30S+ VE50"
self.expected_chips = 164
self.fan_count = 2
@@ -143,7 +143,7 @@ class M30SPlusVE60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE60"
self.raw_model = "M30S+ VE60"
self.expected_chips = 172
self.fan_count = 2
@@ -152,7 +152,7 @@ class M30SPlusVE70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE70"
self.raw_model = "M30S+ VE70"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VE70, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -164,7 +164,7 @@ class M30SPlusVE80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE80"
self.raw_model = "M30S+ VE80"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VE80, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -176,7 +176,7 @@ class M30SPlusVE90(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE90"
self.raw_model = "M30S+ VE90"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VE90, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -188,7 +188,7 @@ class M30SPlusVE100(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VE100"
self.raw_model = "M30S+ VE100"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VE100, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -200,7 +200,7 @@ class M30SPlusVF20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VF20"
self.raw_model = "M30S+ VF20"
self.expected_chips = 111
self.fan_count = 2
@@ -209,7 +209,7 @@ class M30SPlusVF30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VF30"
self.raw_model = "M30S+ VF30"
self.expected_chips = 117
self.fan_count = 2
@@ -218,7 +218,7 @@ class M30SPlusVG20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VG20"
self.raw_model = "M30S+ VG20"
self.expected_chips = 82
self.fan_count = 2
@@ -227,7 +227,7 @@ class M30SPlusVG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VG30"
self.raw_model = "M30S+ VG30"
self.expected_chips = 78
self.fan_count = 2
@@ -236,7 +236,7 @@ class M30SPlusVG40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VG40"
self.raw_model = "M30S+ VG40"
self.expected_chips = 105
self.fan_count = 2
@@ -245,7 +245,7 @@ class M30SPlusVG50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VG50"
self.raw_model = "M30S+ VG50"
self.expected_chips = 111
self.fan_count = 2
@@ -254,7 +254,7 @@ class M30SPlusVG60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VG60"
self.raw_model = "M30S+ VG60"
self.expected_chips = 86
self.fan_count = 2
@@ -263,7 +263,7 @@ class M30SPlusVH10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VH10"
self.raw_model = "M30S+ VH10"
self.expected_chips = 64
self.fan_count = 2
@@ -272,7 +272,7 @@ class M30SPlusVH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VH20"
self.raw_model = "M30S+ VH20"
self.expected_chips = 66
self.fan_count = 2
@@ -281,7 +281,7 @@ class M30SPlusVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VH30"
self.raw_model = "M30S+ VH30"
self.expected_chips = 70
self.fan_count = 2
@@ -290,7 +290,7 @@ class M30SPlusVH40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VH40"
self.raw_model = "M30S+ VH40"
self.expected_chips = 74
self.fan_count = 2
@@ -299,7 +299,7 @@ class M30SPlusVH50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VH50"
self.raw_model = "M30S+ VH50"
self.expected_chips = 64
self.fan_count = 2
@@ -308,6 +308,6 @@ class M30SPlusVH60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S+ VH60"
self.raw_model = "M30S+ VH60"
self.expected_chips = 66
self.fan_count = 2

42
pyasic/miners/types/whatsminer/M3X/M30S_Plus_Plus.py
View File

@@ -23,7 +23,7 @@ class M30SPlusPlusV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ V10"
self.raw_model = "M30S++ V10"
self.expected_hashboards = 4
self.expected_chips = 255
self.fan_count = 2
@@ -33,7 +33,7 @@ class M30SPlusPlusV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ V20"
self.raw_model = "M30S++ V20"
self.expected_hashboards = 4
self.expected_chips = 255
self.fan_count = 2
@@ -43,7 +43,7 @@ class M30SPlusPlusVE30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VE30"
self.raw_model = "M30S++ VE30"
self.expected_chips = 215
self.fan_count = 2
@@ -52,7 +52,7 @@ class M30SPlusPlusVE40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VE40"
self.raw_model = "M30S++ VE40"
self.expected_chips = 225
self.fan_count = 2
@@ -61,7 +61,7 @@ class M30SPlusPlusVE50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VE50"
self.raw_model = "M30S++ VE50"
self.expected_chips = 235
self.fan_count = 2
@@ -70,7 +70,7 @@ class M30SPlusPlusVF40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VF40"
self.raw_model = "M30S++ VF40"
self.expected_chips = 156
self.fan_count = 2
@@ -79,7 +79,7 @@ class M30SPlusPlusVG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VG30"
self.raw_model = "M30S++ VG30"
self.expected_chips = 111
self.fan_count = 2
@@ -88,7 +88,7 @@ class M30SPlusPlusVG40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VG40"
self.raw_model = "M30S++ VG40"
self.expected_chips = 117
self.fan_count = 2
@@ -97,7 +97,7 @@ class M30SPlusPlusVG50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VG50"
self.raw_model = "M30S++ VG50"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S++ VG50, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -109,7 +109,7 @@ class M30SPlusPlusVH10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH10"
self.raw_model = "M30S++ VH10"
self.expected_chips = 82
self.fan_count = 2
@@ -118,7 +118,7 @@ class M30SPlusPlusVH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH20"
self.raw_model = "M30S++ VH20"
self.expected_chips = 86
self.fan_count = 2
@@ -127,7 +127,7 @@ class M30SPlusPlusVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH30"
self.raw_model = "M30S++ VH30"
self.expected_chips = 111
self.fan_count = 2
@@ -136,7 +136,7 @@ class M30SPlusPlusVH40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH40"
self.raw_model = "M30S++ VH40"
self.expected_chips = 70
self.fan_count = 2
@@ -145,7 +145,7 @@ class M30SPlusPlusVH50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH50"
self.raw_model = "M30S++ VH50"
self.expected_chips = 74
self.fan_count = 2
@@ -154,7 +154,7 @@ class M30SPlusPlusVH60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH60"
self.raw_model = "M30S++ VH60"
self.expected_chips = 78
self.fan_count = 2
@@ -163,7 +163,7 @@ class M30SPlusPlusVH70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH70"
self.raw_model = "M30S++ VH70"
self.expected_chips = 70
self.fan_count = 2
@@ -172,7 +172,7 @@ class M30SPlusPlusVH80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH80"
self.raw_model = "M30S++ VH80"
self.expected_chips = 74
self.fan_count = 2
@@ -181,7 +181,7 @@ class M30SPlusPlusVH90(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH90"
self.raw_model = "M30S++ VH90"
self.expected_chips = 78
self.fan_count = 2
@@ -190,7 +190,7 @@ class M30SPlusPlusVH100(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VH100"
self.raw_model = "M30S++ VH100"
self.expected_chips = 82
self.fan_count = 2
@@ -199,7 +199,7 @@ class M30SPlusPlusVJ20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VJ20"
self.raw_model = "M30S++ VJ20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S++ VJ20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -211,7 +211,7 @@ class M30SPlusPlusVJ30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M30S++ VJ30"
self.raw_model = "M30S++ VJ30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S++ VJ30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

6
pyasic/miners/types/whatsminer/M3X/M31.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M31V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31 V10"
self.raw_model = "M31 V10"
self.expected_chips = 70
self.fan_count = 2
@@ -32,6 +30,6 @@ class M31V20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31 V20"
self.raw_model = "M31 V20"
self.expected_chips = 74
self.fan_count = 2

6
pyasic/miners/types/whatsminer/M3X/M31H.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M31HV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31H V10"
self.raw_model = "M31H V10"
self.expected_chips = 114
self.fan_count = 0
@@ -32,7 +30,7 @@ class M31HV40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31H V40"
self.raw_model = "M31H V40"
self.expected_hashboards = 4
self.expected_chips = 136
self.fan_count = 0

4
pyasic/miners/types/whatsminer/M3X/M31L.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,6 +21,6 @@ class M31LV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31L V10"
self.raw_model = "M31L V10"
self.expected_chips = 114
self.fan_count = 2

24
pyasic/miners/types/whatsminer/M3X/M31S.py
View File

@@ -23,7 +23,7 @@ class M31SV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V10"
self.raw_model = "M31S V10"
self.expected_chips = 105
self.fan_count = 2
@@ -32,7 +32,7 @@ class M31SV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V20"
self.raw_model = "M31S V20"
self.expected_chips = 111
self.fan_count = 2
@@ -41,7 +41,7 @@ class M31SV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V30"
self.raw_model = "M31S V30"
self.expected_chips = 117
self.fan_count = 2
@@ -50,7 +50,7 @@ class M31SV40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V40"
self.raw_model = "M31S V40"
self.expected_chips = 123
self.fan_count = 2
@@ -59,7 +59,7 @@ class M31SV50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V50"
self.raw_model = "M31S V50"
self.expected_chips = 78
self.fan_count = 2
@@ -68,7 +68,7 @@ class M31SV60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V60"
self.raw_model = "M31S V60"
self.expected_chips = 105
self.fan_count = 2
@@ -77,7 +77,7 @@ class M31SV70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V70"
self.raw_model = "M31S V70"
self.expected_chips = 111
self.fan_count = 2
@@ -86,7 +86,7 @@ class M31SV80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V80"
self.raw_model = "M31S V80"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M31SV80, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -98,7 +98,7 @@ class M31SV90(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S V90"
self.raw_model = "M31S V90"
self.expected_chips = 117
self.fan_count = 2
@@ -107,7 +107,7 @@ class M31SVE10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S VE10"
self.raw_model = "M31S VE10"
self.expected_chips = 70
self.fan_count = 2
@@ -116,7 +116,7 @@ class M31SVE20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S VE20"
self.raw_model = "M31S VE20"
self.expected_chips = 74
self.fan_count = 2
@@ -125,7 +125,7 @@ class M31SVE30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S VE30"
self.raw_model = "M31S VE30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M31SVE30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

8
pyasic/miners/types/whatsminer/M3X/M31SE.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M31SEV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31SE V10"
self.raw_model = "M31SE V10"
self.expected_chips = 82
self.fan_count = 2
@@ -32,7 +30,7 @@ class M31SEV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31SE V20"
self.raw_model = "M31SE V20"
self.expected_chips = 78
self.fan_count = 2
@@ -41,6 +39,6 @@ class M31SEV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31SE V30"
self.raw_model = "M31SE V30"
self.expected_chips = 78
self.fan_count = 2

44
pyasic/miners/types/whatsminer/M3X/M31S_Plus.py
View File

@@ -23,7 +23,7 @@ class M31SPlusV10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V10"
self.raw_model = "M31S+ V10"
self.expected_chips = 105
self.fan_count = 2
@@ -32,7 +32,7 @@ class M31SPlusV20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V20"
self.raw_model = "M31S+ V20"
self.expected_chips = 111
self.fan_count = 2
@@ -41,7 +41,7 @@ class M31SPlusV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V30"
self.raw_model = "M31S+ V30"
self.expected_chips = 117
self.fan_count = 2
@@ -50,7 +50,7 @@ class M31SPlusV40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V40"
self.raw_model = "M31S+ V40"
self.expected_chips = 123
self.fan_count = 2
@@ -59,7 +59,7 @@ class M31SPlusV50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V50"
self.raw_model = "M31S+ V50"
self.expected_chips = 148
self.fan_count = 2
@@ -68,7 +68,7 @@ class M31SPlusV60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V60"
self.raw_model = "M31S+ V60"
self.expected_chips = 156
self.fan_count = 2
@@ -77,7 +77,7 @@ class M31SPlusV80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V80"
self.raw_model = "M31S+ V80"
self.expected_chips = 129
self.fan_count = 2
@@ -86,7 +86,7 @@ class M31SPlusV90(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V90"
self.raw_model = "M31S+ V90"
self.expected_chips = 117
self.fan_count = 2
@@ -95,7 +95,7 @@ class M31SPlusV100(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V100"
self.raw_model = "M31S+ V100"
self.expected_chips = 111
self.fan_count = 2
@@ -104,7 +104,7 @@ class M31SPlusVE10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE10"
self.raw_model = "M31S+ VE10"
self.expected_chips = 82
self.fan_count = 2
@@ -113,7 +113,7 @@ class M31SPlusVE20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE20"
self.raw_model = "M31S+ VE20"
self.expected_chips = 78
self.fan_count = 2
@@ -122,7 +122,7 @@ class M31SPlusVE30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE30"
self.raw_model = "M31S+ VE30"
self.expected_chips = 105
self.fan_count = 2
@@ -131,7 +131,7 @@ class M31SPlusVE40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE40"
self.raw_model = "M31S+ VE40"
self.expected_chips = 111
self.fan_count = 2
@@ -140,7 +140,7 @@ class M31SPlusVE50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE50"
self.raw_model = "M31S+ VE50"
self.expected_chips = 117
self.fan_count = 2
@@ -149,7 +149,7 @@ class M31SPlusVE60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE60"
self.raw_model = "M31S+ VE60"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VE60, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -161,7 +161,7 @@ class M31SPlusVE80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VE80"
self.raw_model = "M31S+ VE80"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VE80, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -173,7 +173,7 @@ class M31SPlusVF20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VF20"
self.raw_model = "M31S+ VF20"
self.expected_chips = 66
self.fan_count = 2
@@ -182,7 +182,7 @@ class M31SPlusVF30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VF30"
self.raw_model = "M31S+ VF30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M30S+ VF30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -194,7 +194,7 @@ class M31SPlusVG20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VG20"
self.raw_model = "M31S+ VG20"
self.expected_chips = 66
self.fan_count = 2
@@ -203,7 +203,7 @@ class M31SPlusVG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ VG30"
self.raw_model = "M31S+ VG30"
self.expected_chips = 70
self.fan_count = 2
@@ -212,7 +212,7 @@ class M31SPlusV30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V30"
self.raw_model = "M31S+ V30"
self.expected_chips = 117
self.fan_count = 2
@@ -221,6 +221,6 @@ class M31SPlusV40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M31S+ V40"
self.raw_model = "M31S+ V40"
self.expected_chips = 123
self.fan_count = 2

6
pyasic/miners/types/whatsminer/M3X/M32.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M32V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M32 V10"
self.raw_model = "M32 V10"
self.expected_chips = 78
self.fan_count = 2
@@ -32,6 +30,6 @@ class M32V20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M32 V20"
self.raw_model = "M32 V20"
self.expected_chips = 74
self.fan_count = 2

2
pyasic/miners/types/whatsminer/M3X/M32S.py
View File

@@ -21,6 +21,6 @@ class M32S(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M32S"
self.raw_model = "M32S"
self.expected_chips = 78
self.fan_count = 2

8
pyasic/miners/types/whatsminer/M3X/M33.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M33V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33 V10"
self.raw_model = "M33 V10"
self.expected_chips = 33
self.fan_count = 0
@@ -32,7 +30,7 @@ class M33V20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33 V20"
self.raw_model = "M33 V20"
self.expected_chips = 62
self.fan_count = 0
@@ -41,6 +39,6 @@ class M33V30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33 V30"
self.raw_model = "M33 V30"
self.expected_chips = 66
self.fan_count = 0

4
pyasic/miners/types/whatsminer/M3X/M33S.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M33SVG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S VG30"
self.raw_model = "M33S VG30"
self.expected_hashboards = 4
self.expected_chips = 116
self.fan_count = 0

6
pyasic/miners/types/whatsminer/M3X/M33S_Plus.py
View File

@@ -23,7 +23,7 @@ class M33SPlusVG20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S+ VG20"
self.raw_model = "M33S+ VG20"
self.expected_hashboards = 4
self.expected_chips = 112
self.fan_count = 0
@@ -33,7 +33,7 @@ class M33SPlusVH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S+ VH20"
self.raw_model = "M33S+ VH20"
self.expected_hashboards = 4
self.expected_chips = 100
self.fan_count = 0
@@ -43,7 +43,7 @@ class M33SPlusVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S+ VH30"
self.raw_model = "M33S+ VH30"
self.expected_hashboards = 4
self.expected_chips = 0 # slot1 116, slot2 106, slot3 116, slot4 106
warnings.warn(

6
pyasic/miners/types/whatsminer/M3X/M33S_Plus_Plus.py
View File

@@ -23,7 +23,7 @@ class M33SPlusPlusVH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S++ VH20"
self.raw_model = "M33S++ VH20"
self.expected_hashboards = 4
self.expected_chips = 112
self.fan_count = 0
@@ -33,7 +33,7 @@ class M33SPlusPlusVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S++ VH30"
self.raw_model = "M33S++ VH30"
self.expected_hashboards = 4
self.expected_chips = 0
warnings.warn(
@@ -46,7 +46,7 @@ class M33SPlusPlusVG40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M33S++ VG40"
self.raw_model = "M33S++ VG40"
self.expected_hashboards = 4
self.expected_chips = 174
self.fan_count = 0

2
pyasic/miners/types/whatsminer/M3X/M34S_Plus.py
View File

@@ -21,7 +21,7 @@ class M34SPlusVE10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M34S+ VE10"
self.raw_model = "M34S+ VE10"
self.expected_hashboards = 4
self.expected_chips = 116
self.fan_count = 0

4
pyasic/miners/types/whatsminer/M3X/M36S.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M36SVE10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M36S VE10"
self.raw_model = "M36S VE10"
self.expected_hashboards = 4
self.expected_chips = 114
self.fan_count = 0

4
pyasic/miners/types/whatsminer/M3X/M36S_Plus.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M36SPlusVG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M36S+ VG30"
self.raw_model = "M36S+ VG30"
self.expected_hashboards = 4
self.expected_chips = 108
self.fan_count = 0

4
pyasic/miners/types/whatsminer/M3X/M36S_Plus_Plus.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M36SPlusPlusVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M36S++ VH30"
self.raw_model = "M36S++ VH30"
self.expected_hashboards = 4
self.expected_chips = 80
self.fan_count = 0

8
pyasic/miners/types/whatsminer/M3X/M39.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M39V10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M39 V10"
self.raw_model = "M39 V10"
self.expected_chips = 50
self.fan_count = 0
@@ -32,7 +30,7 @@ class M39V20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M39 V20"
self.raw_model = "M39 V20"
self.expected_chips = 54
self.fan_count = 0
@@ -41,6 +39,6 @@ class M39V30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M39 V30"
self.raw_model = "M39 V30"
self.expected_chips = 68
self.fan_count = 0

26
pyasic/miners/types/whatsminer/M5X/M50.py
View File

@@ -23,7 +23,7 @@ class M50VE30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VE30"
self.raw_model = "M50 VE30"
self.expected_hashboards = 4
self.expected_chips = 255
self.fan_count = 2
@@ -33,7 +33,7 @@ class M50VG30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VG30"
self.raw_model = "M50 VG30"
self.expected_chips = 156
self.fan_count = 2
@@ -42,7 +42,7 @@ class M50VH10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH10"
self.raw_model = "M50 VH10"
self.expected_chips = 86
self.fan_count = 2
@@ -51,7 +51,7 @@ class M50VH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH20"
self.raw_model = "M50 VH20"
self.expected_chips = 111
self.fan_count = 2
@@ -60,7 +60,7 @@ class M50VH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH30"
self.raw_model = "M50 VH30"
self.expected_chips = 117
self.fan_count = 2
@@ -69,7 +69,7 @@ class M50VH40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH40"
self.raw_model = "M50 VH40"
self.expected_chips = 84
self.fan_count = 2
@@ -78,7 +78,7 @@ class M50VH50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH50"
self.raw_model = "M50 VH50"
self.expected_chips = 105
self.fan_count = 2
@@ -87,7 +87,7 @@ class M50VH60(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH60"
self.raw_model = "M50 VH60"
self.expected_chips = 84
self.fan_count = 2
@@ -96,7 +96,7 @@ class M50VH70(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH70"
self.raw_model = "M50 VH70"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50 VH70, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -108,7 +108,7 @@ class M50VH80(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VH80"
self.raw_model = "M50 VH80"
self.expected_chips = 111
self.fan_count = 2
@@ -117,7 +117,7 @@ class M50VJ10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VJ10"
self.raw_model = "M50 VJ10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50 VJ10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -129,7 +129,7 @@ class M50VJ20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VJ20"
self.raw_model = "M50 VJ20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50 VJ20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -141,7 +141,7 @@ class M50VJ30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50 VJ30"
self.raw_model = "M50 VJ30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50 VJ30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

16
pyasic/miners/types/whatsminer/M5X/M50S.py
View File

@@ -23,7 +23,7 @@ class M50SVJ10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VJ10"
self.raw_model = "M50S VJ10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S VJ10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M50SVJ20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VJ20"
self.raw_model = "M50S VJ20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S VJ20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,7 +47,7 @@ class M50SVJ30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VJ30"
self.raw_model = "M50S VJ30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S VJ30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -59,7 +59,7 @@ class M50SVH10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VH10"
self.raw_model = "M50S VH10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S VH10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -71,7 +71,7 @@ class M50SVH20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VH20"
self.raw_model = "M50S VH20"
self.expected_chips = 135
self.fan_count = 2
@@ -80,7 +80,7 @@ class M50SVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VH30"
self.raw_model = "M50S VH30"
self.expected_chips = 156
self.fan_count = 2
@@ -89,7 +89,7 @@ class M50SVH40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VH40"
self.raw_model = "M50S VH40"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S VH40, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -101,7 +101,7 @@ class M50SVH50(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S VH50"
self.raw_model = "M50S VH50"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S VH50, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

8
pyasic/miners/types/whatsminer/M5X/M50S_Plus.py
View File

@@ -23,7 +23,7 @@ class M50SPlusVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S+ VH30"
self.raw_model = "M50S+ VH30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S+ VH30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M50SPlusVH40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S+ VH40"
self.raw_model = "M50S+ VH40"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S+ VH40, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,7 +47,7 @@ class M50SPlusVJ30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S+ VJ30"
self.raw_model = "M50S+ VJ30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S+ VJ30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -59,6 +59,6 @@ class M50SPlusVK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S+ VK20"
self.raw_model = "M50S+ VK20"
self.expected_chips = 117
self.fan_count = 2

6
pyasic/miners/types/whatsminer/M5X/M50S_Plus_Plus.py
View File

@@ -23,7 +23,7 @@ class M50SPlusPlusVK10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S++ VK10"
self.raw_model = "M50S++ VK10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S+ VK10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M50SPlusPlusVK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S++ VK20"
self.raw_model = "M50S++ VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M50S+ VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,6 +47,6 @@ class M50SPlusPlusVK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M50S++ VK30"
self.raw_model = "M50S++ VK30"
self.expected_chips = 76
self.fan_count = 2

4
pyasic/miners/types/whatsminer/M5X/M53.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M53VH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M53 VH30"
self.raw_model = "M53 VH30"
self.expected_hashboards = 4
self.expected_chips = 128
self.fan_count = 0

2
pyasic/miners/types/whatsminer/M5X/M53S.py
View File

@@ -23,7 +23,7 @@ class M53SVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M53S VH30"
self.raw_model = "M53S VH30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M53S VH30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

2
pyasic/miners/types/whatsminer/M5X/M53S_Plus.py
View File

@@ -23,7 +23,7 @@ class M53SPlusVJ30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M53S+ VJ30"
self.raw_model = "M53S+ VJ30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M53S+ VJ30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

4
pyasic/miners/types/whatsminer/M5X/M56.py
View File

@@ -14,8 +14,6 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import warnings
from pyasic.miners.makes import WhatsMiner
@@ -23,7 +21,7 @@ class M56VH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M56 VH30"
self.raw_model = "M56 VH30"
self.expected_hashboards = 4
self.expected_chips = 108
self.fan_count = 0

2
pyasic/miners/types/whatsminer/M5X/M56S.py
View File

@@ -23,7 +23,7 @@ class M56SVH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M56S VH30"
self.raw_model = "M56S VH30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M56S VH30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

2
pyasic/miners/types/whatsminer/M5X/M56S_Plus.py
View File

@@ -23,7 +23,7 @@ class M56SPlusVJ30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M56S+ VJ30"
self.raw_model = "M56S+ VJ30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M56S+ VJ30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

2
pyasic/miners/types/whatsminer/M5X/M59.py
View File

@@ -23,7 +23,7 @@ class M59VH30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M59 VH30"
self.raw_model = "M59 VH30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M59 VH30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

8
pyasic/miners/types/whatsminer/M6X/M60.py
View File

@@ -23,7 +23,7 @@ class M60VK10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60 VK10"
self.raw_model = "M60 VK10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60 VK10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M60VK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60 VK20"
self.raw_model = "M60 VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60 VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,7 +47,7 @@ class M60VK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60 VK30"
self.raw_model = "M60 VK30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60 VK30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -59,7 +59,7 @@ class M60VK40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60 VK40"
self.raw_model = "M60 VK40"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60 VK40, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

8
pyasic/miners/types/whatsminer/M6X/M60S.py
View File

@@ -23,7 +23,7 @@ class M60SVK10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60S VK10"
self.raw_model = "M60S VK10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60S VK10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M60SVK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60S VK20"
self.raw_model = "M60S VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60S VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,7 +47,7 @@ class M60SVK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60S VK30"
self.raw_model = "M60S VK30"
self.expected_hashboards = 3
self.expected_chips = 78
self.fan_count = 2
@@ -57,7 +57,7 @@ class M60SVK40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M60S VK40"
self.raw_model = "M60S VK40"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M60S VK40, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

6
pyasic/miners/types/whatsminer/M6X/M63.py
View File

@@ -23,7 +23,7 @@ class M63VK10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M63 VK10"
self.raw_model = "M63 VK10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M63 VK10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M63VK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M63 VK20"
self.raw_model = "M63 VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M63 VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,7 +47,7 @@ class M63VK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M63 VK30"
self.raw_model = "M63 VK30"
self.expected_chips = 68
self.expected_hashboards = 4
self.fan_count = 0

6
pyasic/miners/types/whatsminer/M6X/M63S.py
View File

@@ -23,7 +23,7 @@ class M63SVK10(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M63S VK10"
self.raw_model = "M63S VK10"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M63S VK10, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M63SVK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M63S VK20"
self.raw_model = "M63S VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M63S VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -47,7 +47,7 @@ class M63SVK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M63S VK30"
self.raw_model = "M63S VK30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M63S VK30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

4
pyasic/miners/types/whatsminer/M6X/M66.py
View File

@@ -23,7 +23,7 @@ class M66VK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M66 VK20"
self.raw_model = "M66 VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M66 VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M66VK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M66 VK30"
self.raw_model = "M66 VK30"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M66 VK30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

6
pyasic/miners/types/whatsminer/M6X/M66S.py
View File

@@ -23,7 +23,7 @@ class M66SVK20(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M66S VK20"
self.raw_model = "M66S VK20"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M66S VK20, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."
@@ -35,7 +35,7 @@ class M66SVK30(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M66S VK30"
self.raw_model = "M66S VK30"
self.expected_chips = 96
self.expected_hashboards = 4
self.fan_count = 0
@@ -45,7 +45,7 @@ class M66SVK40(WhatsMiner): # noqa - ignore ABC method implementation
def __init__(self, ip: str, api_ver: str = "0.0.0"):
super().__init__(ip, api_ver)
self.ip = ip
self.model = "M66S VK40"
self.raw_model = "M66S VK40"
self.expected_chips = 0
warnings.warn(
"Unknown chip count for miner type M66 VK30, please open an issue on GitHub (https://github.com/UpstreamData/pyasic)."

1
pyasic/miners/unknown.py
View File

@@ -20,7 +20,6 @@ from pyasic.API.unknown import UnknownAPI
from pyasic.config import MinerConfig
from pyasic.data import Fan, HashBoard, MinerData
from pyasic.data.error_codes import MinerErrorData
from pyasic.errors import APIError
from pyasic.miners.base import BaseMiner

1
pyasic/web/__init__.py
View File

@@ -13,7 +13,6 @@
# See the License for the specific language governing permissions and -
# limitations under the License. -
# ------------------------------------------------------------------------------
import ipaddress
import warnings
from abc import ABC, abstractmethod
from typing import Union

3
pyasic/web/epic.py
View File

@@ -14,13 +14,12 @@
# limitations under the License. -
# ------------------------------------------------------------------------------
import json
import warnings
from typing import Union
import httpx
from pyasic import settings
from pyasic.errors import APIError, APIWarning
from pyasic.errors import APIError
from pyasic.web import BaseWebAPI

2
tests/__init__.py
View File

@@ -17,6 +17,8 @@
import unittest
from tests.api_tests import *
from tests.config_tests import TestConfig
from tests.miners_tests import MinersTest
from tests.network_tests import NetworkTest
if __name__ == "__main__":

Some files were not shown because too many files have changed in this diff Show More