version: bump version number.

fix send_config for ePIC

pyasic/config/mining.py

@@ -111,21 +111,21 @@ class MiningModeHPM(MinerConfigValue):
 class StandardPowerTuneAlgo(MinerConfigValue):
     mode: str = field(init=False, default="standard")
 
-    def as_epic(self):
+    def as_epic(self) -> str:
         return VOptPowerTuneAlgo().as_epic()
 
 
 class VOptPowerTuneAlgo(MinerConfigValue):
     mode: str = field(init=False, default="standard")
 
-    def as_epic(self):
+    def as_epic(self) -> str:
         return "VoltageOptimizer"
 
 
 class ChipTunePowerTuneAlgo(MinerConfigValue):
     mode: str = field(init=False, default="standard")
 
-    def as_epic(self):
+    def as_epic(self) -> str:
         return "ChipTune"
 
 
@@ -184,7 +184,7 @@ class MiningModePowerTune(MinerConfigValue):
         return {"mode": {"mode": "custom", "tune": "power", "power": self.power}}
 
     def as_epic(self) -> dict:
-        return {"ptune": {**self.algo.as_epic(), "target": self.power}}
+        return {"ptune": {"algo": self.algo.as_epic(), "target": self.power}}
 
 
 @dataclass

pyasic/config/pools.py

@@ -265,15 +265,7 @@ class PoolGroup(MinerConfigValue):
         return [p.as_auradine(user_suffix=user_suffix) for p in self.pools]
 
     def as_epic(self, user_suffix: str = None) -> dict:
-        if len(self.pools) > 0:
-            conf = {
-                "name": self.name,
-                "pool": [pool.as_epic(user_suffix=user_suffix) for pool in self.pools],
-            }
-            if self.quota is not None:
-                conf["quota"] = self.quota
-            return conf
-        return {"name": self.name, "pool": []}
+        return [p.as_epic(user_suffix=user_suffix) for p in self.pools]
 
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "PoolGroup":
@@ -421,9 +413,7 @@ class PoolConfig(MinerConfigValue):
             return {
                 "pools": {
                     "coin": "Btc",
-                    "stratum_configs": [
-                        g.as_epic(user_suffix=user_suffix) for g in self.groups
-                    ],
+                    "stratum_configs": self.groups[0].as_epic(user_suffix=user_suffix),
                     "unique_id": False,
                 }
             }

pyasic/config/temperature.py

@@ -43,9 +43,9 @@ class TemperatureConfig(MinerConfigValue):
     def as_epic(self) -> dict:
         temps_config = {"temps": {}, "fans": {"Auto": {}}}
         if self.target is not None:
-            temps_config["fans"]["Target Temperature"] = self.target
+            temps_config["fans"]["Auto"]["Target Temperature"] = self.target
         else:
-            temps_config["fans"]["Target Temperature"] = 60
+            temps_config["fans"]["Auto"]["Target Temperature"] = 60
         if self.danger is not None:
             temps_config["temps"]["shutdown"] = self.danger
         return temps_config

pyasic/miners/antminer/bosminer/X17/S17.py

@@ -14,21 +14,21 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from pyasic.miners.backends import BOSer
+from pyasic.miners.backends import BOSMiner
 from pyasic.miners.models import S17, S17e, S17Plus, S17Pro
 
 
-class BOSMinerS17(BOSer, S17):
+class BOSMinerS17(BOSMiner, S17):
     pass
 
 
-class BOSMinerS17Plus(BOSer, S17Plus):
+class BOSMinerS17Plus(BOSMiner, S17Plus):
     pass
 
 
-class BOSMinerS17Pro(BOSer, S17Pro):
+class BOSMinerS17Pro(BOSMiner, S17Pro):
     pass
 
 
-class BOSMinerS17e(BOSer, S17e):
+class BOSMinerS17e(BOSMiner, S17e):
     pass

pyasic/miners/antminer/bosminer/X17/T17.py

@@ -14,17 +14,17 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from pyasic.miners.backends import BOSer
+from pyasic.miners.backends import BOSMiner
 from pyasic.miners.models import T17, T17e, T17Plus
 
 
-class BOSMinerT17(BOSer, T17):
+class BOSMinerT17(BOSMiner, T17):
     pass
 
 
-class BOSMinerT17Plus(BOSer, T17Plus):
+class BOSMinerT17Plus(BOSMiner, T17Plus):
     pass
 
 
-class BOSMinerT17e(BOSer, T17e):
+class BOSMinerT17e(BOSMiner, T17e):
     pass

pyasic/miners/backends/bfgminer.py

@@ -68,7 +68,7 @@ class BFGMiner(BaseMiner):
         except APIError:
             return self.config
 
-        self.config = MinerConfig.from_rpc(pools)
+        self.config = MinerConfig.from_api(pools)
         return self.config
 
     ##################################################
@@ -84,11 +84,11 @@ class BFGMiner(BaseMiner):
 
         if rpc_version is not None:
             try:
-                self.rpc_ver = rpc_version["VERSION"][0]["API"]
+                self.api_ver = rpc_version["VERSION"][0]["API"]
             except LookupError:
                 pass
 
-        return self.rpc_ver
+        return self.api_ver
 
     async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
         if rpc_version is None:

pyasic/miners/backends/bmminer.py

@@ -72,7 +72,7 @@ class BMMiner(BaseMiner):
         except APIError:
             return self.config
 
-        self.config = MinerConfig.from_rpc(pools)
+        self.config = MinerConfig.from_api(pools)
         return self.config
 
     ##################################################
@@ -88,11 +88,11 @@ class BMMiner(BaseMiner):
 
         if rpc_version is not None:
             try:
-                self.rpc_ver = rpc_version["VERSION"][0]["API"]
+                self.api_ver = rpc_version["VERSION"][0]["API"]
             except LookupError:
                 pass
 
-        return self.rpc_ver
+        return self.api_ver
 
     async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
         if rpc_version is None:

pyasic/miners/backends/braiins_os.py

@@ -305,10 +305,10 @@ class BOSMiner(BaseMiner):
                 rpc_ver = rpc_version["VERSION"][0]["API"]
             except LookupError:
                 rpc_ver = None
-            self.rpc_ver = rpc_ver
-            self.rpc.rpc_ver = self.rpc_ver
+            self.api_ver = rpc_ver
+            self.rpc.rpc_ver = self.api_ver
 
-        return self.rpc_ver
+        return self.api_ver
 
     async def _get_fw_ver(self, web_bos_info: dict = None) -> Optional[str]:
         if web_bos_info is None:
@@ -731,10 +731,10 @@ class BOSer(BaseMiner):
                 rpc_ver = rpc_version["VERSION"][0]["API"]
             except LookupError:
                 rpc_ver = None
-            self.rpc_ver = rpc_ver
-            self.rpc.rpc_ver = self.rpc_ver
+            self.api_ver = rpc_ver
+            self.rpc.rpc_ver = self.api_ver
 
-        return self.rpc_ver
+        return self.api_ver
 
     async def _get_fw_ver(self, grpc_miner_details: dict = None) -> Optional[str]:
         if grpc_miner_details is None:

pyasic/miners/backends/btminer.py

@@ -234,7 +234,7 @@ class BTMiner(BaseMiner):
             pass
 
         if pools is not None:
-            cfg = MinerConfig.from_rpc(pools)
+            cfg = MinerConfig.from_api(pools)
         else:
             cfg = MinerConfig()
 
@@ -325,14 +325,14 @@ class BTMiner(BaseMiner):
                         rpc_ver = rpc_get_version["Msg"]
                         if not isinstance(rpc_ver, str):
                             rpc_ver = rpc_ver["rpc_ver"]
-                        self.rpc_ver = rpc_ver.replace("whatsminer v", "")
+                        self.api_ver = rpc_ver.replace("whatsminer v", "")
                     except (KeyError, TypeError):
                         pass
                     else:
-                        self.rpc.rpc_ver = self.rpc_ver
-                        return self.rpc_ver
+                        self.rpc.rpc_ver = self.api_ver
+                        return self.api_ver
 
-        return self.rpc_ver
+        return self.api_ver
 
     async def _get_fw_ver(
         self, rpc_get_version: dict = None, rpc_summary: dict = None

pyasic/miners/backends/cgminer.py

@@ -71,7 +71,7 @@ class CGMiner(BaseMiner):
         except APIError:
             return self.config
 
-        self.config = MinerConfig.from_rpc(pools)
+        self.config = MinerConfig.from_api(pools)
         return self.config
 
     ##################################################
@@ -87,11 +87,11 @@ class CGMiner(BaseMiner):
 
         if rpc_version is not None:
             try:
-                self.rpc_ver = rpc_version["VERSION"][0]["API"]
+                self.api_ver = rpc_version["VERSION"][0]["API"]
             except LookupError:
                 pass
 
-        return self.rpc_ver
+        return self.api_ver
 
     async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
         if rpc_version is None:

pyasic/miners/backends/epic.py

@@ -116,6 +116,7 @@ class ePIC(BaseMiner):
             if not conf.get("temps", {}) == {}:
                 await self.web.set_shutdown_temp(conf["temps"]["shutdown"])
             # Fans
+            # set with sub-keys instead of conf["fans"] because sometimes both can be set
             if not conf["fans"].get("Manual", {}) == {}:
                 await self.web.set_fan({"Manual": conf["fans"]["Manual"]})
             elif not conf["fans"].get("Auto", {}) == {}:

pyasic/misc/__init__.py

@@ -107,3 +107,4 @@ def validate_command_output(data: dict) -> tuple[bool, str | None]:
                 if data[key][0]["STATUS"][0]["STATUS"] not in ["S", "I"]:
                     # this is an error
                     return False, f"{key}: " + data[key][0]["STATUS"][0]["Msg"]
+        return True, None

pyasic/rpc/base.py

@@ -90,7 +90,7 @@ class BaseMinerRPCAPI:
         if not validation[0]:
             if not ignore_errors:
                 # validate the command succeeded
-                raise APIError(validation[1])
+                raise APIError(f"{command}: {validation[1]}")
             if allow_warning:
                 logging.warning(
                     f"{self.ip}: API Command Error: {command}: {validation[1]}"

pyasic/rpc/btminer.py

@@ -29,7 +29,7 @@ from passlib.handlers.md5_crypt import md5_crypt
 
 from pyasic import settings
 from pyasic.errors import APIError
-from pyasic.misc import api_min_version
+from pyasic.misc import api_min_version, validate_command_output
 from pyasic.rpc.base import BaseMinerRPCAPI
 
 ### IMPORTANT ###
@@ -272,7 +272,7 @@ class BTMinerRPCAPI(BaseMinerRPCAPI):
 
         if not ignore_errors:
             # if it fails to validate, it is likely an error
-            validation = self._validate_command_output(data)
+            validation = validate_command_output(data)
             if not validation[0]:
                 raise APIError(validation[1])
 
@@ -607,10 +607,10 @@ class BTMinerRPCAPI(BaseMinerRPCAPI):
             A reply informing of the status of setting the frequency.
         </details>
         """
-        if not -10 < percent < 100:
+        if not -100 < percent < 100:
             raise APIError(
                 f"Frequency % is outside of the allowed "
-                f"range.  Please set a % between -10 and "
+                f"range.  Please set a % between -100 and "
                 f"100"
             )
         return await self.send_privileged_command(

pyasic/web/braiins_os/boser.py

@@ -70,13 +70,15 @@ class BOSerWebAPI(BaseWebAPI):
             not func.startswith("__") and not func.startswith("_")
         ]
 
-    async def multicommand(self, *commands: str) -> dict:
+    async def multicommand(
+        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
+    ) -> dict:
         result = {"multicommand": True}
         tasks = {}
         for command in commands:
             try:
                 tasks[command] = asyncio.create_task(getattr(self, command)())
-            except AttributeError:
+            except (APIError, AttributeError):
                 result["command"] = {}
 
         await asyncio.gather(*list(tasks.values()))

pyasic/web/braiins_os/bosminer.py

@@ -59,10 +59,14 @@ class BOSMinerWebAPI(BaseWebAPI):
                 return {}
             raise APIError(f"LUCI web command failed: command={command}")
 
-    async def multicommand(self, *commands: str) -> dict:
+    async def multicommand(
+        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
+    ) -> dict:
         data = {}
         for command in commands:
-            data[command] = await self.send_command(command, ignore_errors=True)
+            data[command] = await self.send_command(
+                command, ignore_errors=ignore_errors
+            )
         return data
 
     async def auth(self, session: httpx.AsyncClient) -> None:

pyasic/web/epic.py

@@ -44,40 +44,37 @@ class ePICWebAPI(BaseWebAPI):
         post = privileged or not parameters == {}
 
         async with httpx.AsyncClient(transport=settings.transport()) as client:
-            for i in range(settings.get("get_data_retries", 1) + 1):
-                try:
-                    if post:
-                        response = await client.post(
-                            f"http://{self.ip}:{self.port}/{command}",
-                            timeout=5,
-                            json={
-                                **parameters,
-                                "password": self.pwd,
-                            },
+            try:
+                if post:
+                    response = await client.post(
+                        f"http://{self.ip}:{self.port}/{command}",
+                        timeout=5,
+                        json={
+                            **parameters,
+                            "password": self.pwd,
+                        },
+                    )
+                else:
+                    response = await client.get(
+                        f"http://{self.ip}:{self.port}/{command}",
+                        timeout=5,
+                    )
+                if not response.status_code == 200:
+                    if not ignore_errors:
+                        raise APIError(
+                            f"Web command {command} failed with status code {response.status_code}"
                         )
-                    else:
-                        response = await client.get(
-                            f"http://{self.ip}:{self.port}/{command}",
-                            timeout=5,
-                        )
-                    if not response.status_code == 200:
-                        continue
-                    json_data = response.json()
-                    if json_data:
-                        # The API can return a fail status if the miner cannot return the requested data. Catch this and pass
-                        if (
-                            "result" in json_data
-                            and json_data["result"] is False
-                            and not post
-                        ):
-                            if not i > settings.get("get_data_retries", 1):
-                                continue
-                            if not ignore_errors:
-                                raise APIError(json_data["error"])
-                        return json_data
-                    return {"success": True}
-                except (httpx.HTTPError, json.JSONDecodeError, AttributeError):
-                    pass
+                    return {}
+                json_data = response.json()
+                if json_data:
+                    # The API can return a fail status if the miner cannot return the requested data. Catch this and pass
+                    if not json_data.get("result", True) and not post:
+                        if not ignore_errors:
+                            raise APIError(json_data["error"])
+                    return json_data
+                return {"success": True}
+            except (httpx.HTTPError, json.JSONDecodeError, AttributeError):
+                pass
 
     async def multicommand(
         self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
@@ -95,19 +92,19 @@ class ePICWebAPI(BaseWebAPI):
         return await self.send_command("reboot", privileged=True)
 
     async def set_shutdown_temp(self, params: int) -> dict:
-        return await self.send_command("shutdowntemp", parameters=params)
+        return await self.send_command("shutdowntemp", param=params)
 
     async def set_fan(self, params: dict) -> dict:
-        return await self.send_command("fanspeed", parameters=params)
+        return await self.send_command("fanspeed", param=params)
 
     async def set_ptune_enable(self, params: bool) -> dict:
-        return await self.send_command("perpetualtune", parameters=params)
+        return await self.send_command("perpetualtune", param=params)
 
     async def set_ptune_algo(self, params: dict) -> dict:
-        return await self.send_command("perpetualtune/algo", parameters=params)
+        return await self.send_command("perpetualtune/algo", param=params)
 
     async def set_pools(self, params: dict) -> dict:
-        return await self.send_command("coin", parameters=params)
+        return await self.send_command("coin", param=params)
 
     async def pause_mining(self) -> dict:
         return await self.send_command("miner", param="Stop")

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.50.1"
+version = "0.50.6"
 description = "A simplified and standardized interface for Bitcoin ASICs."
 authors = ["UpstreamData <brett@upstreamdata.ca>"]
 repository = "https://github.com/UpstreamData/pyasic"