refactor: remove parameters from get_{x} functions and move them to _get_{x}(**params). Add miner.fw_str, and miner.raw_model. Remove model from get_data exclude. Swap fan_count to expected_fans.

2024-01-11 11:33:44 -07:00
parent aa9ba66f8e
commit a8c45cb95d
3 changed files with 66 additions and 90 deletions
--- a/pyasic/miners/backends/btminer.py
+++ b/pyasic/miners/backends/btminer.py
@@ -35,74 +35,73 @@ from pyasic.miners.base import (
 BTMINER_DATA_LOC = DataLocations(
    **{
        str(DataOptions.MAC): DataFunction(
-            "get_mac",
+            "_get_mac",
            [
                RPCAPICommand("api_summary", "summary"),
                RPCAPICommand("api_get_miner_info", "get_miner_info"),
            ],
        ),
-        str(DataOptions.MODEL): DataFunction("get_model"),
        str(DataOptions.API_VERSION): DataFunction(
-            "get_api_ver", [RPCAPICommand("api_get_version", "get_version")]
+            "_get_api_ver", [RPCAPICommand("api_get_version", "get_version")]
        ),
        str(DataOptions.FW_VERSION): DataFunction(
-            "get_fw_ver",
+            "_get_fw_ver",
            [
                RPCAPICommand("api_get_version", "get_version"),
                RPCAPICommand("api_summary", "summary"),
            ],
        ),
        str(DataOptions.HOSTNAME): DataFunction(
-            "get_hostname", [RPCAPICommand("api_get_miner_info", "get_miner_info")]
+            "_get_hostname", [RPCAPICommand("api_get_miner_info", "get_miner_info")]
        ),
        str(DataOptions.HASHRATE): DataFunction(
-            "get_hashrate", [RPCAPICommand("api_summary", "summary")]
+            "_get_hashrate", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
-            "get_expected_hashrate", [RPCAPICommand("api_summary", "summary")]
+            "_get_expected_hashrate", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.HASHBOARDS): DataFunction(
-            "get_hashboards", [RPCAPICommand("api_devs", "devs")]
+            "_get_hashboards", [RPCAPICommand("api_devs", "devs")]
        ),
        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
-            "get_env_temp", [RPCAPICommand("api_summary", "summary")]
+            "_get_env_temp", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.WATTAGE): DataFunction(
-            "get_wattage", [RPCAPICommand("api_summary", "summary")]
+            "_get_wattage", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.WATTAGE_LIMIT): DataFunction(
-            "get_wattage_limit", [RPCAPICommand("api_summary", "summary")]
+            "_get_wattage_limit", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.FANS): DataFunction(
-            "get_fans",
+            "_get_fans",
            [
                RPCAPICommand("api_summary", "summary"),
                RPCAPICommand("api_get_psu", "get_psu"),
            ],
        ),
        str(DataOptions.FAN_PSU): DataFunction(
-            "get_fan_psu",
+            "_get_fan_psu",
            [
                RPCAPICommand("api_summary", "summary"),
                RPCAPICommand("api_get_psu", "get_psu"),
            ],
        ),
        str(DataOptions.ERRORS): DataFunction(
-            "get_errors",
+            "_get_errors",
            [
                RPCAPICommand("api_get_error_code", "get_error_code"),
                RPCAPICommand("api_summary", "summary"),
            ],
        ),
        str(DataOptions.FAULT_LIGHT): DataFunction(
-            "get_fault_light",
+            "_get_fault_light",
            [RPCAPICommand("api_get_miner_info", "get_miner_info")],
        ),
        str(DataOptions.IS_MINING): DataFunction(
-            "is_mining", [RPCAPICommand("api_status", "status")]
+            "_is_mining", [RPCAPICommand("api_status", "status")]
        ),
        str(DataOptions.UPTIME): DataFunction(
-            "get_uptime", [RPCAPICommand("api_summary", "summary")]
+            "_get_uptime", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.CONFIG): DataFunction("get_config"),
    }
@@ -243,7 +242,7 @@ class BTMiner(BaseMiner):
        else:
            cfg = MinerConfig()

-        is_mining = await self.is_mining(status)
+        is_mining = await self._is_mining(status)
        if not is_mining:
            cfg.mining_mode = MiningModeConfig.sleep()
            return cfg
@@ -287,7 +286,7 @@ class BTMiner(BaseMiner):
    ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
    ##################################################

-    async def get_mac(
+    async def _get_mac(
        self, api_summary: dict = None, api_get_miner_info: dict = None
    ) -> Optional[str]:
        if not api_get_miner_info:
@@ -316,21 +315,7 @@ class BTMiner(BaseMiner):
            except (KeyError, IndexError):
                pass

-    async def get_version(
-        self, api_get_version: dict = None, api_summary: dict = None
-    ) -> Tuple[Optional[str], Optional[str]]:
-        miner_version = namedtuple("MinerVersion", "api_ver fw_ver")
-        api_ver = await self.get_api_ver(api_get_version=api_get_version)
-        fw_ver = await self.get_fw_ver(
-            api_get_version=api_get_version, api_summary=api_summary
-        )
-        return miner_version(api_ver, fw_ver)
-
-    async def get_api_ver(self, api_get_version: dict = None) -> Optional[str]:
-        # Check to see if the version info is already cached
-        if self.api_ver:
-            return self.api_ver
-
+    async def _get_api_ver(self, api_get_version: dict = None) -> Optional[str]:
        if not api_get_version:
            try:
                api_get_version = await self.api.get_version()
@@ -353,13 +338,9 @@ class BTMiner(BaseMiner):

        return self.api_ver

-    async def get_fw_ver(
+    async def _get_fw_ver(
        self, api_get_version: dict = None, api_summary: dict = None
    ) -> Optional[str]:
-        # Check to see if the version info is already cached
-        if self.fw_ver:
-            return self.fw_ver
-
        if not api_get_version:
            try:
                api_get_version = await self.api.get_version()
@@ -392,7 +373,7 @@ class BTMiner(BaseMiner):

        return self.fw_ver

-    async def get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]:
+    async def _get_hostname(self, api_get_miner_info: dict = None) -> Optional[str]:
        hostname = None
        if not api_get_miner_info:
            try:
@@ -408,7 +389,7 @@ class BTMiner(BaseMiner):

        return hostname

-    async def get_hashrate(self, api_summary: dict = None) -> Optional[float]:
+    async def _get_hashrate(self, api_summary: dict = None) -> Optional[float]:
        # get hr from API
        if not api_summary:
            try:
@@ -422,7 +403,7 @@ class BTMiner(BaseMiner):
            except (KeyError, IndexError):
                pass

-    async def get_hashboards(self, api_devs: dict = None) -> List[HashBoard]:
+    async def _get_hashboards(self, api_devs: dict = None) -> List[HashBoard]:
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -457,7 +438,7 @@ class BTMiner(BaseMiner):

        return hashboards

-    async def get_env_temp(self, api_summary: dict = None) -> Optional[float]:
+    async def _get_env_temp(self, api_summary: dict = None) -> Optional[float]:
        if not api_summary:
            try:
                api_summary = await self.api.summary()
@@ -470,7 +451,7 @@ class BTMiner(BaseMiner):
            except (KeyError, IndexError):
                pass

-    async def get_wattage(self, api_summary: dict = None) -> Optional[int]:
+    async def _get_wattage(self, api_summary: dict = None) -> Optional[int]:
        if not api_summary:
            try:
                api_summary = await self.api.summary()
@@ -484,7 +465,7 @@ class BTMiner(BaseMiner):
            except (KeyError, IndexError):
                pass

-    async def get_wattage_limit(self, api_summary: dict = None) -> Optional[int]:
+    async def _get_wattage_limit(self, api_summary: dict = None) -> Optional[int]:
        if not api_summary:
            try:
                api_summary = await self.api.summary()
@@ -497,7 +478,7 @@ class BTMiner(BaseMiner):
            except (KeyError, IndexError):
                pass

-    async def get_fans(
+    async def _get_fans(
        self, api_summary: dict = None, api_get_psu: dict = None
    ) -> List[Fan]:
        if not api_summary:
@@ -506,10 +487,10 @@ class BTMiner(BaseMiner):
            except APIError:
                pass

-        fans = [Fan() for _ in range(self.fan_count)]
+        fans = [Fan() for _ in range(self.expected_fans)]
        if api_summary:
            try:
-                if self.fan_count > 0:
+                if self.expected_fans > 0:
                    fans = [
                        Fan(api_summary["SUMMARY"][0].get("Fan Speed In", 0)),
                        Fan(api_summary["SUMMARY"][0].get("Fan Speed Out", 0)),
@@ -519,7 +500,7 @@ class BTMiner(BaseMiner):

        return fans

-    async def get_fan_psu(
+    async def _get_fan_psu(
        self, api_summary: dict = None, api_get_psu: dict = None
    ) -> Optional[int]:
        if not api_summary:
@@ -546,7 +527,7 @@ class BTMiner(BaseMiner):
            except (KeyError, TypeError):
                pass

-    async def get_errors(
+    async def _get_errors(
        self, api_summary: dict = None, api_get_error_code: dict = None
    ) -> List[MinerErrorData]:
        errors = []
@@ -581,7 +562,7 @@ class BTMiner(BaseMiner):

        return errors

-    async def get_expected_hashrate(self, api_summary: dict = None):
+    async def _get_expected_hashrate(self, api_summary: dict = None):
        if not api_summary:
            try:
                api_summary = await self.api.summary()
@@ -596,7 +577,7 @@ class BTMiner(BaseMiner):
            except (KeyError, IndexError):
                pass

-    async def get_fault_light(self, api_get_miner_info: dict = None) -> bool:
+    async def _get_fault_light(self, api_get_miner_info: dict = None) -> bool:
        if not api_get_miner_info:
            try:
                api_get_miner_info = await self.api.get_miner_info()
@@ -634,7 +615,7 @@ class BTMiner(BaseMiner):
    async def set_hostname(self, hostname: str):
        await self.api.set_hostname(hostname)

-    async def is_mining(self, api_status: dict = None) -> Optional[bool]:
+    async def _is_mining(self, api_status: dict = None) -> Optional[bool]:
        if not api_status:
            try:
                api_status = await self.api.status()
@@ -653,7 +634,7 @@ class BTMiner(BaseMiner):
            except LookupError:
                pass

-    async def get_uptime(self, api_summary: dict = None) -> Optional[int]:
+    async def _get_uptime(self, api_summary: dict = None) -> Optional[int]:
        if not api_summary:
            try:
                api_summary = await self.api.summary()
--- a/pyasic/miners/backends/cgminer_avalon.py
+++ b/pyasic/miners/backends/cgminer_avalon.py
@@ -28,42 +28,41 @@ from pyasic.miners.base import DataFunction, DataLocations, DataOptions, RPCAPIC
 AVALON_DATA_LOC = DataLocations(
    **{
        str(DataOptions.MAC): DataFunction(
-            "get_mac", [RPCAPICommand("api_version", "version")]
+            "_get_mac", [RPCAPICommand("api_version", "version")]
        ),
-        str(DataOptions.MODEL): DataFunction("get_model"),
        str(DataOptions.API_VERSION): DataFunction(
-            "get_api_ver", [RPCAPICommand("api_version", "version")]
+            "_get_api_ver", [RPCAPICommand("api_version", "version")]
        ),
        str(DataOptions.FW_VERSION): DataFunction(
-            "get_fw_ver", [RPCAPICommand("api_version", "version")]
+            "_get_fw_ver", [RPCAPICommand("api_version", "version")]
        ),
-        str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
+        str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
        str(DataOptions.HASHRATE): DataFunction(
-            "get_hashrate", [RPCAPICommand("api_devs", "devs")]
+            "_get_hashrate", [RPCAPICommand("api_devs", "devs")]
        ),
        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
-            "get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
+            "_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.HASHBOARDS): DataFunction(
-            "get_hashboards", [RPCAPICommand("api_stats", "stats")]
+            "_get_hashboards", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
-            "get_env_temp", [RPCAPICommand("api_stats", "stats")]
+            "_get_env_temp", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.WATTAGE): DataFunction("get_wattage"),
+        str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
        str(DataOptions.WATTAGE_LIMIT): DataFunction(
-            "get_wattage_limit", [RPCAPICommand("api_stats", "stats")]
+            "_get_wattage_limit", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.FANS): DataFunction(
-            "get_fans", [RPCAPICommand("api_stats", "stats")]
+            "_get_fans", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
-        str(DataOptions.ERRORS): DataFunction("get_errors"),
+        str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
+        str(DataOptions.ERRORS): DataFunction("_get_errors"),
        str(DataOptions.FAULT_LIGHT): DataFunction(
-            "get_fault_light", [RPCAPICommand("api_stats", "stats")]
+            "_get_fault_light", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.IS_MINING): DataFunction("is_mining"),
-        str(DataOptions.UPTIME): DataFunction("get_uptime"),
+        str(DataOptions.IS_MINING): DataFunction("_is_mining"),
+        str(DataOptions.UPTIME): DataFunction("_get_uptime"),
        str(DataOptions.CONFIG): DataFunction("get_config"),
    }
 )
@@ -174,7 +173,7 @@ class CGMinerAvalon(CGMiner):
    ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
    ##################################################

-    async def get_mac(self, api_version: dict = None) -> Optional[str]:
+    async def _get_mac(self, api_version: dict = None) -> Optional[str]:
        if not api_version:
            try:
                api_version = await self.api.version()
@@ -192,7 +191,7 @@ class CGMinerAvalon(CGMiner):
            except (KeyError, ValueError):
                pass

-    async def get_hostname(self) -> Optional[str]:
+    async def _get_hostname(self) -> Optional[str]:
        return None
        # if not mac:
        #     mac = await self.get_mac()
@@ -200,7 +199,7 @@ class CGMinerAvalon(CGMiner):
        # if mac:
        #     return f"Avalon{mac.replace(':', '')[-6:]}"

-    async def get_hashrate(self, api_devs: dict = None) -> Optional[float]:
+    async def _get_hashrate(self, api_devs: dict = None) -> Optional[float]:
        if not api_devs:
            try:
                api_devs = await self.api.devs()
@@ -213,7 +212,7 @@ class CGMinerAvalon(CGMiner):
            except (KeyError, IndexError, ValueError, TypeError):
                pass

-    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
+    async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -261,7 +260,7 @@ class CGMinerAvalon(CGMiner):

        return hashboards

-    async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
+    async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -276,7 +275,7 @@ class CGMinerAvalon(CGMiner):
            except (IndexError, KeyError, ValueError, TypeError):
                pass

-    async def get_env_temp(self, api_stats: dict = None) -> Optional[float]:
+    async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -291,10 +290,10 @@ class CGMinerAvalon(CGMiner):
            except (IndexError, KeyError, ValueError, TypeError):
                pass

-    async def get_wattage(self) -> Optional[int]:
+    async def _get_wattage(self) -> Optional[int]:
        return None

-    async def get_wattage_limit(self, api_stats: dict = None) -> Optional[int]:
+    async def _get_wattage_limit(self, api_stats: dict = None) -> Optional[int]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -309,14 +308,14 @@ class CGMinerAvalon(CGMiner):
            except (IndexError, KeyError, ValueError, TypeError):
                pass

-    async def get_fans(self, api_stats: dict = None) -> List[Fan]:
+    async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
            except APIError:
                pass

-        fans_data = [Fan() for _ in range(self.fan_count)]
+        fans_data = [Fan() for _ in range(self.expected_fans)]
        if api_stats:
            try:
                unparsed_stats = api_stats["STATS"][0]["MM ID0"]
@@ -324,17 +323,17 @@ class CGMinerAvalon(CGMiner):
            except LookupError:
                return fans_data

-            for fan in range(self.fan_count):
+            for fan in range(self.expected_fans):
                try:
                    fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"])
                except (IndexError, KeyError, ValueError, TypeError):
                    pass
        return fans_data

-    async def get_errors(self) -> List[MinerErrorData]:
+    async def _get_errors(self) -> List[MinerErrorData]:
        return []

-    async def get_fault_light(self, api_stats: dict = None) -> bool:  # noqa
+    async def _get_fault_light(self, api_stats: dict = None) -> bool:  # noqa
        if self.light:
            return self.light
        if not api_stats:
@@ -363,7 +362,7 @@ class CGMinerAvalon(CGMiner):
            pass
        return False

-    async def is_mining(self, *args, **kwargs) -> Optional[bool]:
+    async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
        return None

    async def get_uptime(self) -> Optional[int]:
--- a/pyasic/miners/backends/hiveon.py
+++ b/pyasic/miners/backends/hiveon.py
@@ -68,14 +68,10 @@ class Hiveon(BMMiner):
        self.pwd = "admin"
        # static data
        self.api_type = "Hiveon"
+        self.fw_str = "Hive"
        # data gathering locations
        self.data_locations = HIVEON_DATA_LOC

-    async def get_model(self) -> Optional[str]:
-        if self.model is not None:
-            return self.model + " (Hiveon)"
-        return "? (Hiveon)"
-
    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
        pass