version: bump version number

* Docs for Mini Doge

* Mini Doge Recognition Support

* Loading fixes

* Fix for number of fans

* Fixed expected_hashrate

* Fixes for hashboards

* Implemented uptime

* Fixed uptime

* Doc fixes

* Fixes for byte

* Copyright update

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Typo fix

* File renames

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

docs/miners/goldshell/Byte.md

@@ -3,8 +3,8 @@
 
 ## Byte (Stock)
 
-- [x] Shutdowns
-- [x] Power Modes
+- [ ] Shutdowns
+- [ ] Power Modes
 - [ ] Setpoints
 - [ ] Presets
 

docs/miners/goldshell/MiniDoge.md

@@ -0,0 +1,16 @@
+# pyasic
+## Mini Doge Models
+
+## Mini Doge (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.goldshell.bfgminer.MiniDoge.MiniDoge.GoldshellMiniDoge
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+

docs/miners/supported_types.md

@@ -38,6 +38,7 @@ details {
         <details>
             <summary>X7 Series:</summary>
                 <ul>
+                    <li><a href="../antminer/X7#l7-stock">L7 (Stock)</a></li>
                     <li><a href="../antminer/X7#l7-stock">L7 (Stock)</a></li>
                     <li><a href="../antminer/X7#k7-stock">K7 (Stock)</a></li>
                     <li><a href="../antminer/X7#d7-stock">D7 (Stock)</a></li>
@@ -53,6 +54,7 @@ details {
                     <li><a href="../antminer/X9#s9j-stock">S9j (Stock)</a></li>
                     <li><a href="../antminer/X9#t9-stock">T9 (Stock)</a></li>
                     <li><a href="../antminer/X9#l9-stock">L9 (Stock)</a></li>
+                    <li><a href="../antminer/X9#l9-stock">L9 (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -601,6 +603,12 @@ details {
 <details>
 <summary>Stock Firmware Goldshells:</summary>
     <ul>
+        <details>
+            <summary>Mini Doge Series:</summary>
+                <ul>
+                    <li><a href="../goldshell/MiniDoge#mini-doge-stock">Mini Doge (Stock)</a></li>
+                </ul>
+        </details>
         <details>
             <summary>X5 Series:</summary>
                 <ul>

mkdocs.yml

@@ -98,6 +98,7 @@ nav:
         - Innosilicon A10X: "miners/innosilicon/A10X.md"
         - Innosilicon A11X: "miners/innosilicon/A11X.md"
         - Goldshell Byte: "miners/goldshell/Byte.md"
+        - Goldshell Mini Doge: "miners/goldshell/MiniDoge.md"
         - Goldshell X5: "miners/goldshell/X5.md"
         - Goldshell XMax: "miners/goldshell/XMax.md"
         - Goldshell XBox: "miners/goldshell/XBox.md"

pyasic/config/__init__.py

@@ -254,6 +254,11 @@ class MinerConfig(BaseModel):
         """Constructs a MinerConfig object from web configuration for Goldshell miners."""
         return cls(pools=PoolConfig.from_am_modern(web_conf))
 
+    @classmethod
+    def from_goldshell_list(cls, web_conf: list) -> "MinerConfig":
+        """Constructs a MinerConfig object from web configuration for Goldshell miners."""
+        return cls(pools=PoolConfig.from_goldshell(web_conf))
+
     @classmethod
     def from_goldshell_byte(cls, web_conf: dict) -> "MinerConfig":
         """Constructs a MinerConfig object from web configuration for Goldshell Byte miners."""

pyasic/device/models.py

@@ -480,6 +480,7 @@ class GoldshellModels(MinerModelType):
     KDBoxII = "KD Box II"
     KDBoxPro = "KD Box Pro"
     Byte = "Byte"
+    MiniDoge = "Mini Doge"
 
     def __str__(self):
         return self.value

pyasic/miners/backends/bfgminer.py

@@ -216,7 +216,7 @@ class BFGMiner(StockFirmware):
                     )
             except LookupError:
                 pass
-        fans = [Fan(speed=d) if d else Fan() for d in fans_data]
+        fans = [Fan(speed=d) for d in fans_data if d is not None]
 
         return fans
 

pyasic/miners/backends/btminer.py

@@ -783,67 +783,67 @@ class BTMinerV2(StockFirmware):
 BTMINERV3_DATA_LOC = DataLocations(
     **{
         str(DataOptions.MAC): DataFunction(
-            "_get_mac", [RPCAPICommand("rpc_get_device_info", "get_device_info")]
+            "_get_mac", [RPCAPICommand("rpc_get_device_info", "get.device.info")]
         ),
         str(DataOptions.API_VERSION): DataFunction(
             "_get_api_version",
-            [RPCAPICommand("rpc_get_device_info", "get_device_info")],
+            [RPCAPICommand("rpc_get_device_info", "get.device.info")],
         ),
         str(DataOptions.FW_VERSION): DataFunction(
             "_get_firmware_version",
-            [RPCAPICommand("rpc_get_device_info", "get_device_info")],
+            [RPCAPICommand("rpc_get_device_info", "get.device.info")],
         ),
         str(DataOptions.HOSTNAME): DataFunction(
-            "_get_hostname", [RPCAPICommand("rpc_get_device_info", "get_device_info")]
+            "_get_hostname", [RPCAPICommand("rpc_get_device_info", "get.device.info")]
         ),
         str(DataOptions.FAULT_LIGHT): DataFunction(
             "_get_light_flashing",
-            [RPCAPICommand("rpc_get_device_info", "get_device_info")],
+            [RPCAPICommand("rpc_get_device_info", "get.device.info")],
         ),
         str(DataOptions.WATTAGE_LIMIT): DataFunction(
             "_get_wattage_limit",
-            [RPCAPICommand("rpc_get_device_info", "get_device_info")],
+            [RPCAPICommand("rpc_get_device_info", "get.device.info")],
         ),
         str(DataOptions.FANS): DataFunction(
             "_get_fans",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.FAN_PSU): DataFunction(
-            "_get_psu_fans", [RPCAPICommand("rpc_get_device_info", "get_device_info")]
+            "_get_psu_fans", [RPCAPICommand("rpc_get_device_info", "get.device.info")]
         ),
         str(DataOptions.HASHBOARDS): DataFunction(
             "_get_hashboards",
             [
-                RPCAPICommand("rpc_get_device_info", "get_device_info"),
+                RPCAPICommand("rpc_get_device_info", "get.device.info"),
                 RPCAPICommand(
                     "rpc_get_miner_status_edevs",
-                    "get_miner_status_edevs",
+                    "get.miner.status:edevs",
                 ),
             ],
         ),
         str(DataOptions.POOLS): DataFunction(
             "_get_pools",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.UPTIME): DataFunction(
             "_get_uptime",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.WATTAGE): DataFunction(
             "_get_wattage",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.HASHRATE): DataFunction(
             "_get_hashrate",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.EXPECTED_HASHRATE): DataFunction(
             "_get_expected_hashrate",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
             "_get_env_temp",
-            [RPCAPICommand("rpc_get_miner_status_summary", "get_miner_status_summary")],
+            [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
     }
 )
@@ -1082,7 +1082,9 @@ class BTMinerV3(StockFirmware):
                     temp=board_data.get("chip-temp-min"),
                     inlet_temp=board_data.get("chip-temp-min"),
                     outlet_temp=board_data.get("chip-temp-max"),
-                    serial_number=board_data.get(f"pcbsn{idx}"),
+                    serial_number=rpc_get_device_info.get("msg", {})
+                    .get("miner", {})
+                    .get(f"pcbsn{idx}"),
                     chips=board_data.get("effective-chips"),
                     expected_chips=self.expected_chips,
                     active=(board_data.get("hash-average") or 0) > 0,
@@ -1164,12 +1166,16 @@ class BTMinerV3(StockFirmware):
                 rpc_get_miner_status_summary = await self.rpc.get_miner_status_summary()
             except APIError:
                 return None
-        return (
+        res = (
             rpc_get_miner_status_summary.get("msg", {})
             .get("summary", {})
             .get("factory-hash")
         )
 
+        if res == (-0.001 * self.expected_hashboards):
+            return None
+        return res
+
     async def _get_env_temp(
         self, rpc_get_miner_status_summary: dict = None
     ) -> float | None:

pyasic/miners/backends/elphapex.py

@@ -233,9 +233,10 @@ class ElphapexMiner(StockFirmware):
                     board_temp_data = list(
                         filter(lambda x: not x == 0, board["temp_pcb"])
                     )
-                    hashboards[board["index"]].temp = sum(board_temp_data) / len(
-                        board_temp_data
-                    )
+                    if not len(board_temp_data) == 0:
+                        hashboards[board["index"]].temp = sum(board_temp_data) / len(
+                            board_temp_data
+                        )
                     chip_temp_data = list(
                         filter(lambda x: not x == "", board["temp_chip"])
                     )

pyasic/miners/device/models/goldshell/__init__.py

@@ -13,7 +13,8 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .Byte import *
+from .byte import *
+from .mini_doge import *
 from .X5 import *
 from .XBox import *
 from .XMax import *

pyasic/miners/device/models/goldshell/byte/__init__.py

@@ -1,5 +1,5 @@
 # ------------------------------------------------------------------------------
-#  Copyright 2022 Upstream Data Inc                                            -
+#  Copyright 2025 Upstream Data Inc                                            -
 #                                                                              -
 #  Licensed under the Apache License, Version 2.0 (the "License");             -
 #  you may not use this file except in compliance with the License.            -
@@ -13,4 +13,4 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .Byte import Byte
+from .byte import Byte

pyasic/miners/device/models/goldshell/byte/byte.py

@@ -1,5 +1,5 @@
 # ------------------------------------------------------------------------------
-#  Copyright 2022 Upstream Data Inc                                            -
+#  Copyright 2025 Upstream Data Inc                                            -
 #                                                                              -
 #  Licensed under the Apache License, Version 2.0 (the "License");             -
 #  you may not use this file except in compliance with the License.            -

pyasic/miners/device/models/goldshell/mini_doge/__init__.py

@@ -1,5 +1,5 @@
 # ------------------------------------------------------------------------------
-#  Copyright 2022 Upstream Data Inc                                            -
+#  Copyright 2025 Upstream Data Inc                                            -
 #                                                                              -
 #  Licensed under the Apache License, Version 2.0 (the "License");             -
 #  you may not use this file except in compliance with the License.            -
@@ -13,4 +13,4 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .Byte import GoldshellByte
+from .mini_doge import MiniDoge

pyasic/miners/device/models/goldshell/mini_doge/mini_doge.py

@@ -0,0 +1,27 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2025 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.algorithm import MinerAlgo
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import GoldshellMake
+
+
+class MiniDoge(GoldshellMake):
+    raw_model = MinerModel.GOLDSHELL.MiniDoge
+
+    expected_chips = 40
+    expected_fans = 2
+    expected_hashboards = 1
+    algo = MinerAlgo.SCRYPT

pyasic/miners/device/models/iceriver/KSX/KS5.py

@@ -40,5 +40,6 @@ class KS5M(IceRiverMake):
     raw_model = MinerModel.ICERIVER.KS5M
 
     expected_fans = 4
+    expected_chips = 18
     expected_hashboards = 3
     algo = MinerAlgo.KHEAVYHASH

pyasic/miners/factory.py

@@ -82,6 +82,7 @@ MINER_CLASSES = {
         "ANTMINER KS5": BMMinerKS5,
         "ANTMINER KS5 PRO": BMMinerKS5Pro,
         "ANTMINER L7": BMMinerL7,
+        "ANTMINER L7_I": BMMinerL7,
         "ANTMINER K7": BMMinerK7,
         "ANTMINER D7": BMMinerD7,
         "ANTMINER E9 PRO": BMMinerE9Pro,
@@ -91,6 +92,7 @@ MINER_CLASSES = {
         "ANTMINER S9J": BMMinerS9j,
         "ANTMINER T9": BMMinerT9,
         "ANTMINER L9": BMMinerL9,
+        "ANTMINER L9_I": BMMinerL9,
         "ANTMINER Z15": CGMinerZ15,
         "ANTMINER Z15 PRO": BMMinerZ15Pro,
         "ANTMINER S17": BMMinerS17,
@@ -531,6 +533,7 @@ MINER_CLASSES = {
         "GOLDSHELL KDBOXII": GoldshellKDBoxII,
         "GOLDSHELL KDBOXPRO": GoldshellKDBoxPro,
         "GOLDSHELL BYTE": GoldshellByte,
+        "GOLDSHELL MINIDOGE": GoldshellMiniDoge,
     },
     MinerTypes.BRAIINS_OS: {
         None: BOSMiner,

pyasic/miners/goldshell/bfgminer/__init__.py

@@ -13,7 +13,8 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .Byte import *
+from .byte import *
+from .mini_doge import *
 from .X5 import *
 from .XBox import *
 from .XMax import *

pyasic/miners/goldshell/bfgminer/byte/__init__.py

@@ -0,0 +1,16 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2025 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from .byte import GoldshellByte

pyasic/miners/goldshell/bfgminer/byte/byte.py

@@ -1,5 +1,5 @@
 # ------------------------------------------------------------------------------
-#  Copyright 2022 Upstream Data Inc                                            -
+#  Copyright 2025 Upstream Data Inc                                            -
 #                                                                              -
 #  Licensed under the Apache License, Version 2.0 (the "License");             -
 #  you may not use this file except in compliance with the License.            -
@@ -73,14 +73,23 @@ GOLDSHELL_BYTE_DATA_LOC = DataLocations(
             "_get_pools",
             [RPCAPICommand("rpc_pools", "pools")],
         ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [WebAPICommand("web_devs", "devs")],
+        ),
+        str(DataOptions.WATTAGE): DataFunction(
+            "_get_wattage",
+            [WebAPICommand("web_devs", "devs")],
+        ),
     }
 )
 
 
 class GoldshellByte(GoldshellMiner, Byte):
     data_locations = GOLDSHELL_BYTE_DATA_LOC
-
-    cgdev: dict | None = None
+    supports_shutdown = False
+    supports_power_modes = False
+    web_devs: dict | None = None
 
     async def get_data(
         self,
@@ -88,27 +97,22 @@ class GoldshellByte(GoldshellMiner, Byte):
         include: List[Union[str, DataOptions]] = None,
         exclude: List[Union[str, DataOptions]] = None,
     ) -> MinerData:
-        if self.cgdev is None:
+        if self.web_devs is None:
             try:
-                self.cgdev = await self.web.send_command("cgminer?cgminercmd=devs")
+                self.web_devs = await self.web.devs()
             except APIError:
                 pass
 
         scrypt_board_count = 0
         zksnark_board_count = 0
-        total_wattage = 0
-        total_uptime_mins = 0
 
-        for minfo in self.cgdev.get("minfos", []):
+        for minfo in self.web_devs.get("minfos", []):
             algo_name = minfo.get("name")
 
-            for info in minfo.get("infos", []):
+            for _ in minfo.get("infos", []):
                 self.expected_hashboards += 1
                 self.expected_fans += 1
 
-                total_wattage = int(float(info.get("power", 0)))
-                total_uptime_mins = int(info.get("time", 0))
-
                 if algo_name == ALGORITHM_SCRYPT_NAME:
                     scrypt_board_count += 1
                 elif algo_name == ALGORITHM_ZKSNARK_NAME:
@@ -125,12 +129,6 @@ class GoldshellByte(GoldshellMiner, Byte):
 
         data = await super().get_data(allow_warning, include, exclude)
         data.expected_chips = self.expected_chips
-        data.wattage = total_wattage
-        data.uptime = total_uptime_mins
-        data.voltage = 0
-
-        for board in data.hashboards:
-            data.voltage += board.voltage
 
         return data
 
@@ -313,3 +311,39 @@ class GoldshellByte(GoldshellMiner, Byte):
         fans = [Fan(speed=d) if d else Fan() for d in fans_data]
 
         return fans
+
+    async def _get_uptime(self, web_devs: dict = None) -> Optional[int]:
+        if web_devs is None:
+            try:
+                web_devs = await self.web.devs()
+            except APIError:
+                pass
+
+        if web_devs is not None:
+            try:
+                for minfo in self.web_devs.get("minfos", []):
+                    for info in minfo.get("infos", []):
+                        uptime = int(float(info["time"]))
+                        return uptime
+            except KeyError:
+                pass
+
+        return None
+
+    async def _get_wattage(self, web_devs: dict = None) -> Optional[int]:
+        if web_devs is None:
+            try:
+                web_devs = await self.web.devs()
+            except APIError:
+                pass
+
+        if web_devs is not None:
+            try:
+                for minfo in self.web_devs.get("minfos", []):
+                    for info in minfo.get("infos", []):
+                        wattage = int(float(info["power"]))
+                        return wattage
+            except KeyError:
+                pass
+
+        return None

pyasic/miners/goldshell/bfgminer/mini_doge/__init__.py

@@ -0,0 +1,16 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2025 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from .mini_doge import GoldshellMiniDoge

pyasic/miners/goldshell/bfgminer/mini_doge/mini_doge.py

@@ -0,0 +1,179 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2025 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from typing import List, Optional
+
+from pyasic.config import MinerConfig
+from pyasic.data.boards import HashBoard
+from pyasic.device.algorithm import AlgoHashRate
+from pyasic.errors import APIError
+from pyasic.logger import logger
+from pyasic.miners.backends import GoldshellMiner
+from pyasic.miners.data import (
+    DataFunction,
+    DataLocations,
+    DataOptions,
+    RPCAPICommand,
+    WebAPICommand,
+)
+from pyasic.miners.device.models import MiniDoge
+
+GOLDSHELL_MINI_DOGE_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_setting", "setting")],
+        ),
+        str(DataOptions.API_VERSION): DataFunction(
+            "_get_api_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.FW_VERSION): DataFunction(
+            "_get_fw_ver",
+            [WebAPICommand("web_status", "status")],
+        ),
+        str(DataOptions.HASHRATE): DataFunction(
+            "_get_hashrate",
+            [RPCAPICommand("rpc_summary", "summary")],
+        ),
+        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
+            "_get_expected_hashrate",
+            [RPCAPICommand("rpc_devs", "devs")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [
+                RPCAPICommand("rpc_devs", "devs"),
+                RPCAPICommand("rpc_devdetails", "devdetails"),
+            ],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [WebAPICommand("web_devs", "devs")],
+        ),
+    }
+)
+
+
+class GoldshellMiniDoge(GoldshellMiner, MiniDoge):
+    data_locations = GOLDSHELL_MINI_DOGE_DATA_LOC
+    supports_shutdown = False
+    supports_power_modes = False
+
+    async def get_config(self) -> MinerConfig:
+        try:
+            pools = await self.web.pools()
+        except APIError:
+            return self.config
+
+        self.config = MinerConfig.from_goldshell_list(pools)
+        return self.config
+
+    async def _get_expected_hashrate(
+        self, rpc_devs: dict = None
+    ) -> Optional[AlgoHashRate]:
+        if rpc_devs is None:
+            try:
+                rpc_devs = await self.rpc.devs()
+            except APIError:
+                pass
+
+        if rpc_devs is not None:
+            try:
+                hash_rate = rpc_devs["DEVS"][0]["estimate_hash_rate"]
+                return self.algo.hashrate(
+                    rate=float(hash_rate), unit=self.algo.unit.H
+                ).into(self.algo.unit.default)
+            except KeyError:
+                pass
+
+        return None
+
+    async def _get_hashboards(
+        self, rpc_devs: dict = None, rpc_devdetails: dict = None
+    ) -> List[HashBoard]:
+        if rpc_devs is None:
+            try:
+                rpc_devs = await self.rpc.devs()
+            except APIError:
+                pass
+
+        hashboards = [
+            HashBoard(slot=i, expected_chips=self.expected_chips)
+            for i in range(self.expected_hashboards)
+        ]
+
+        if rpc_devs is not None:
+            if rpc_devs.get("DEVS"):
+                for board in rpc_devs["DEVS"]:
+                    if board.get("ID") is not None:
+                        try:
+                            b_id = board["ID"]
+                            hashboards[b_id].hashrate = self.algo.hashrate(
+                                rate=float(board["MHS 20s"]), unit=self.algo.unit.MH
+                            ).into(self.algo.unit.default)
+                            hashboards[b_id].chip_temp = board["tstemp-0"]
+                            hashboards[b_id].temp = board["tstemp-1"]
+                            hashboards[b_id].voltage = board["voltage"]
+                            hashboards[b_id].active = board["Status"] == "Alive"
+                            hashboards[b_id].missing = False
+                        except KeyError:
+                            pass
+            else:
+                logger.error(self, rpc_devs)
+
+        if rpc_devdetails is None:
+            try:
+                rpc_devdetails = await self.rpc.devdetails()
+            except APIError:
+                pass
+
+        if rpc_devdetails is not None:
+            if rpc_devdetails.get("DEVS"):
+                for board in rpc_devdetails["DEVS"]:
+                    if board.get("ID") is not None:
+                        try:
+                            b_id = board["ID"]
+                            hashboards[b_id].chips = board["chips-nr"]
+                        except KeyError:
+                            pass
+            else:
+                logger.error(self, rpc_devdetails)
+
+        return hashboards
+
+    async def _get_uptime(self, web_devs: dict = None) -> Optional[int]:
+        if web_devs is None:
+            try:
+                web_devs = await self.web.devs()
+            except APIError:
+                pass
+
+        if web_devs is not None:
+            try:
+                uptime = int(web_devs["data"][0]["time"])
+                return uptime
+            except KeyError:
+                pass
+
+        return None

pyasic/rpc/btminer.py

@@ -23,6 +23,7 @@ import json
 import logging
 import re
 import struct
+import warnings
 from asyncio import Future, StreamReader, StreamWriter
 from typing import Any, AsyncGenerator, Callable, Literal, Union
 
@@ -31,7 +32,7 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from passlib.handlers.md5_crypt import md5_crypt
 
 from pyasic import settings
-from pyasic.errors import APIError
+from pyasic.errors import APIError, APIWarning
 from pyasic.misc import api_min_version, validate_command_output
 from pyasic.rpc.base import BaseMinerRPCAPI
 
@@ -1107,39 +1108,27 @@ class BTMinerV3RPCAPI(BaseMinerRPCAPI):
     def __init__(self, ip: str, port: int = 4433, api_ver: str = "0.0.0"):
         super().__init__(ip, port, api_ver=api_ver)
 
-        self.reader: StreamReader | None = None
-        self.writer: StreamWriter | None = None
-        self.reader_loop = None
-
         self.salt = None
 
-        self.cmd_results = {}
-        self.cmd_callbacks = {"get.miner.report": set()}
+    async def multicommand(self, *commands: str, allow_warning: bool = True) -> dict:
+        """Creates and sends multiple commands as one command to the miner.
 
-    async def connect(self):
-        self.reader, self.writer = await asyncio.open_connection(
-            str(self.ip), self.port
-        )
-        self.reader_loop = asyncio.create_task(self._read_loop())
+        Parameters:
+            *commands: The commands to send as a multicommand to the miner.
+            allow_warning: A boolean to supress APIWarnings.
 
-    async def disconnect(self):
-        self.writer.close()
-        await self.writer.wait_closed()
-        self.reader_loop.cancel()
+        """
+        commands = self._check_commands(*commands)
+        data = await self._send_split_multicommand(*commands)
+        data["multicommand"] = True
+        return data
 
     async def send_command(
         self, command: str, parameters: Any = None, **kwargs
     ) -> dict:
-        if self.writer is None:
-            await self.connect()
-
-        while command in self.cmd_results:
-            wait_fut = self.cmd_results[command]
-            await wait_fut
-
-        result_fut = Future()
-        self.cmd_results[command] = result_fut
-
+        if ":" in command:
+            parameters = command.split(":")[1]
+            command = command.split(":")[0]
         cmd = {"cmd": command}
         if parameters is not None:
             cmd["param"] = parameters
@@ -1159,33 +1148,80 @@ class BTMinerV3RPCAPI(BaseMinerRPCAPI):
         # send the command
         ser = json.dumps(cmd).encode("utf-8")
         header = struct.pack("<I", len(ser))
-        await self._send_bytes(header + json.dumps(cmd).encode("utf-8"))
+        return json.loads(
+            await self._send_bytes(header + json.dumps(cmd).encode("utf-8"))
+        )
 
-        await result_fut
-        return result_fut.result()
+    async def _send_bytes(
+        self,
+        data: bytes,
+        *,
+        port: int = None,
+        timeout: int = 100,
+    ) -> bytes:
+        if port is None:
+            port = self.port
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Sending")
+        try:
+            # get reader and writer streams
+            reader, writer = await asyncio.open_connection(str(self.ip), port)
+        # handle OSError 121
+        except OSError as e:
+            if e.errno == 121:
+                logging.warning(
+                    f"{self} - ([Hidden] Send Bytes) - Semaphore timeout expired."
+                )
+            return b"{}"
 
-    async def _read_loop(self):
-        while True:
-            result = await self._read_bytes()
-            data = self._load_api_data(result)
-            command = data["desc"]
-            if command in self.cmd_callbacks:
-                callbacks: list[Callable] = self.cmd_callbacks[command]
-                await asyncio.gather(*[callback(data) for callback in callbacks])
-            elif command in self.cmd_results:
-                future: Future = self.cmd_results.pop(command)
-                future.set_result(data)
+        # send the command
+        try:
+            data_task = asyncio.create_task(self._read_bytes(reader, timeout=timeout))
+            logging.debug(f"{self} - ([Hidden] Send Bytes) - Writing")
+            writer.write(data)
+            logging.debug(f"{self} - ([Hidden] Send Bytes) - Draining")
+            await writer.drain()
+
+            await data_task
+            ret_data = data_task.result()
+        except TimeoutError:
+            logging.warning(f"{self} - ([Hidden] Send Bytes) - Read timeout expired.")
+            return b"{}"
+
+        # close the connection
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Closing")
+        writer.close()
+        await writer.wait_closed()
+
+        return ret_data
+
+    def _check_commands(self, *commands) -> list:
+        return_commands = []
+
+        for command in commands:
+            if command.startswith("get.") or command.startswith("set."):
+                return_commands.append(command)
             else:
-                logging.error(f"Received unexpected data for {self}: {data}")
+                warnings.warn(
+                    f"""Removing incorrect command: {command}
+If you are sure you want to use this command please use API.send_command("{command}", ignore_errors=True) instead.""",
+                    APIWarning,
+                )
+        return return_commands
 
-    async def _read_bytes(self, **kwargs) -> bytes:
-        header = await self.reader.readexactly(4)
-        length = struct.unpack("<I", header)[0]
-        return await self.reader.readexactly(length)
+    async def _read_bytes(self, reader: asyncio.StreamReader, timeout: int) -> bytes:
+        ret_data = b""
 
-    async def _send_bytes(self, data: bytes, **kwargs):
-        self.writer.write(data)
-        await self.writer.drain()
+        # loop to receive all the data
+        logging.debug(f"{self} - ([Hidden] Send Bytes) - Receiving")
+        try:
+            header = await reader.readexactly(4)
+            length = struct.unpack("<I", header)[0]
+            ret_data = await reader.readexactly(length)
+        except (asyncio.CancelledError, asyncio.TimeoutError) as e:
+            raise e
+        except Exception as e:
+            logging.warning(f"{self} - ([Hidden] Send Bytes) - API Command Error {e}")
+        return ret_data
 
     async def get_salt(self) -> str:
         if self.salt is not None:

pyasic/web/elphapex.py

@@ -120,18 +120,28 @@ class ElphapexWebAPI(BaseWebAPI):
         """
         auth = httpx.DigestAuth(self.username, self.pwd)
 
-        try:
-            url = f"http://{self.ip}/cgi-bin/{command}.cgi"
-            ret = await client.get(url, auth=auth)
-        except httpx.HTTPError:
-            pass
-        else:
-            if ret.status_code == 200:
-                try:
-                    json_data = ret.json()
-                    return {command: json_data}
-                except json.decoder.JSONDecodeError:
-                    pass
+        async def _send():
+            try:
+                url = f"http://{self.ip}/cgi-bin/{command}.cgi"
+                ret = await client.get(url, auth=auth)
+            except httpx.HTTPError:
+                pass
+            else:
+                if ret.status_code == 200:
+                    try:
+                        json_data = ret.json()
+                        if json_data.get("STATUS", {}).get("STATUS") not in ["S", "I"]:
+                            return None
+                        return {command: json_data}
+                    except json.decoder.JSONDecodeError:
+                        pass
+            return None
+
+        # retry 3 times
+        for i in range(3):
+            res = await _send()
+            if res is not None:
+                return res
         return {command: {}}
 
     async def get_miner_conf(self) -> dict:

pyasic/web/goldshell.py

@@ -103,8 +103,12 @@ class GoldshellWebAPI(BaseWebAPI):
         async with httpx.AsyncClient(transport=settings.transport()) as client:
             for command in commands:
                 try:
+                    uri_commnand = command
+                    if command == "devs":
+                        uri_commnand = "cgminer?cgminercmd=devs"
+
                     response = await client.get(
-                        f"http://{self.ip}:{self.port}/mcb/{command}",
+                        f"http://{self.ip}:{self.port}/mcb/{uri_commnand}",
                         headers={"Authorization": "Bearer " + self.token},
                         timeout=settings.get("api_function_timeout", 5),
                     )
@@ -143,3 +147,6 @@ class GoldshellWebAPI(BaseWebAPI):
 
     async def status(self) -> dict:
         return await self.send_command("status")
+
+    async def devs(self) -> dict:
+        return await self.send_command("cgminer?cgminercmd=devs")

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyasic"
-version = "0.76.0"
+version = "0.76.5"
 
 description = "A simplified and standardized interface for Bitcoin ASICs."
 authors = [{name = "UpstreamData", email = "brett@upstreamdata.ca"}]