version: bump version number

docs/generate_miners.py

@@ -60,6 +60,8 @@ def backend_str(backend: MinerTypes) -> str:
             return "Stock Firmware Hammer Miners"
         case MinerTypes.VOLCMINER:
             return "Stock Firmware Volcminers"
+        case MinerTypes.ELPHAPEX:
+            return "Stock Firmware Elphapex Miners"
     raise TypeError("Unknown miner backend, cannot generate docs")
 
 

docs/miners/antminer/X19.md

@@ -703,6 +703,19 @@
         show_root_heading: false
         heading_level: 0
 
+## S19 No PIC (Hive)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19NoPIC
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19 (LuxOS)
 
 - [x] Shutdowns

docs/miners/elphapex/DGX.md

@@ -0,0 +1,16 @@
+# pyasic
+## DGX Models
+
+## DG1+ (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.elphapex.daoge.DGX.DG1.ElphapexDG1Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+

docs/miners/luckyminer/LV.md

@@ -1,6 +1,19 @@
 # pyasic
 ## LV Models
 
+## LV07 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.luckyminer.espminer.LV.LV07.LuckyMinerLV07
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## LV08 (Stock)
 
 - [ ] Shutdowns

docs/miners/supported_types.md

@@ -763,6 +763,7 @@ details {
                 <ul>
                     <li><a href="../antminer/X19#s19j-pro-hive">S19j Pro (Hive)</a></li>
                     <li><a href="../antminer/X19#s19-hive">S19 (Hive)</a></li>
+                    <li><a href="../antminer/X19#s19-no-pic-hive">S19 No PIC (Hive)</a></li>
                 </ul>
         </details>
     </ul>
@@ -868,6 +869,7 @@ details {
             <summary>LV Series:</summary>
                 <ul>
                     <li><a href="../luckyminer/LV#lv08-stock">LV08 (Stock)</a></li>
+                    <li><a href="../luckyminer/LV#lv07-stock">LV07 (Stock)</a></li>
                 </ul>
         </details>
     </ul>
@@ -912,4 +914,15 @@ details {
                 </ul>
         </details>
     </ul>
+</details>
+<details>
+<summary>Stock Firmware Elphapex Miners:</summary>
+    <ul>
+        <details>
+            <summary>DGX Series:</summary>
+                <ul>
+                    <li><a href="../elphapex/DGX#dg1_1-stock">DG1+ (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
 </details>

poetry.lock

@@ -74,18 +74,18 @@ pywin32 = ["pywin32 (>=227)"]
 
 [[package]]
 name = "babel"
-version = "2.16.0"
+version = "2.17.0"
 description = "Internationalization utilities"
 optional = false
 python-versions = ">=3.8"
 groups = ["docs"]
 files = [
-    {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"},
-    {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"},
+    {file = "babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2"},
+    {file = "babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d"},
 ]
 
 [package.extras]
-dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"]
+dev = ["backports.zoneinfo", "freezegun (>=1.0,<2.0)", "jinja2 (>=3.0)", "pytest (>=6.0)", "pytest-cov", "pytz", "setuptools", "tzdata"]
 
 [[package]]
 name = "betterproto"
@@ -110,14 +110,14 @@ rust-codec = ["betterproto-rust-codec (==0.1.1)"]
 
 [[package]]
 name = "certifi"
-version = "2024.12.14"
+version = "2025.1.31"
 description = "Python package for providing Mozilla's CA Bundle."
 optional = false
 python-versions = ">=3.6"
 groups = ["main", "docs"]
 files = [
-    {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"},
-    {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"},
+    {file = "certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe"},
+    {file = "certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651"},
 ]
 
 [[package]]
@@ -457,14 +457,14 @@ dev = ["flake8", "markdown", "twine", "wheel"]
 
 [[package]]
 name = "griffe"
-version = "1.5.5"
+version = "1.5.6"
 description = "Signatures for entire Python programs. Extract the structure, the frame, the skeleton of your project, to generate API documentation or find breaking changes in your API."
 optional = false
 python-versions = ">=3.9"
 groups = ["docs"]
 files = [
-    {file = "griffe-1.5.5-py3-none-any.whl", hash = "sha256:2761b1e8876c6f1f9ab1af274df93ea6bbadd65090de5f38f4cb5cc84897c7dd"},
-    {file = "griffe-1.5.5.tar.gz", hash = "sha256:35ee5b38b93d6a839098aad0f92207e6ad6b70c3e8866c08ca669275b8cba585"},
+    {file = "griffe-1.5.6-py3-none-any.whl", hash = "sha256:b2a3afe497c6c1f952e54a23095ecc09435016293e77af8478ed65df1022a394"},
+    {file = "griffe-1.5.6.tar.gz", hash = "sha256:181f6666d5aceb6cd6e2da5a2b646cfb431e47a0da1fda283845734b67e10944"},
 ]
 
 [package.dependencies]
@@ -502,19 +502,19 @@ files = [
 
 [[package]]
 name = "h2"
-version = "4.1.0"
-description = "HTTP/2 State-Machine based protocol implementation"
+version = "4.2.0"
+description = "Pure-Python HTTP/2 protocol implementation"
 optional = false
-python-versions = ">=3.6.1"
+python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "h2-4.1.0-py3-none-any.whl", hash = "sha256:03a46bcf682256c95b5fd9e9a99c1323584c3eec6440d379b9903d709476bc6d"},
-    {file = "h2-4.1.0.tar.gz", hash = "sha256:a83aca08fbe7aacb79fec788c9c0bac936343560ed9ec18b82a13a12c28d2abb"},
+    {file = "h2-4.2.0-py3-none-any.whl", hash = "sha256:479a53ad425bb29af087f3458a61d30780bc818e4ebcf01f0b536ba916462ed0"},
+    {file = "h2-4.2.0.tar.gz", hash = "sha256:c8a52129695e88b1a0578d8d2cc6842bbd79128ac685463b887ee278126ad01f"},
 ]
 
 [package.dependencies]
-hpack = ">=4.0,<5"
-hyperframe = ">=6.0,<7"
+hpack = ">=4.1,<5"
+hyperframe = ">=6.1,<7"
 
 [[package]]
 name = "hpack"
@@ -846,14 +846,14 @@ pyyaml = ">=5.1"
 
 [[package]]
 name = "mkdocs-material"
-version = "9.5.50"
+version = "9.6.2"
 description = "Documentation that simply works"
 optional = false
 python-versions = ">=3.8"
 groups = ["docs"]
 files = [
-    {file = "mkdocs_material-9.5.50-py3-none-any.whl", hash = "sha256:f24100f234741f4d423a9d672a909d859668a4f404796be3cf035f10d6050385"},
-    {file = "mkdocs_material-9.5.50.tar.gz", hash = "sha256:ae5fe16f3d7c9ccd05bb6916a7da7420cf99a9ce5e33debd9d40403a090d5825"},
+    {file = "mkdocs_material-9.6.2-py3-none-any.whl", hash = "sha256:71d90dbd63b393ad11a4d90151dfe3dcbfcd802c0f29ce80bebd9bbac6abc753"},
+    {file = "mkdocs_material-9.6.2.tar.gz", hash = "sha256:a3de1c5d4c745f10afa78b1a02f917b9dce0808fb206adc0f5bb48b58c1ca21f"},
 ]
 
 [package.dependencies]
@@ -1326,14 +1326,14 @@ windows-terminal = ["colorama (>=0.4.6)"]
 
 [[package]]
 name = "pymdown-extensions"
-version = "10.14.1"
+version = "10.14.3"
 description = "Extension pack for Python Markdown."
 optional = false
 python-versions = ">=3.8"
 groups = ["docs"]
 files = [
-    {file = "pymdown_extensions-10.14.1-py3-none-any.whl", hash = "sha256:637951cbfbe9874ba28134fb3ce4b8bcadd6aca89ac4998ec29dcbafd554ae08"},
-    {file = "pymdown_extensions-10.14.1.tar.gz", hash = "sha256:b65801996a0cd4f42a3110810c306c45b7313c09b0610a6f773730f2a9e3c96b"},
+    {file = "pymdown_extensions-10.14.3-py3-none-any.whl", hash = "sha256:05e0bee73d64b9c71a4ae17c72abc2f700e8bc8403755a00580b49a4e9f189e9"},
+    {file = "pymdown_extensions-10.14.3.tar.gz", hash = "sha256:41e576ce3f5d650be59e900e4ceff231e0aed2a88cf30acaee41e02f063a061b"},
 ]
 
 [package.dependencies]

pyasic/config/mining/algo.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import field
 from typing import TypeVar, Union
 
 from pyasic.config.base import MinerConfigOption, MinerConfigValue

pyasic/config/mining/scaling.py

@@ -15,8 +15,6 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from dataclasses import dataclass
-
 from pyasic.config.base import MinerConfigValue
 
 

pyasic/config/temperature.py

@@ -15,8 +15,6 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from dataclasses import dataclass
-
 from pyasic.config.base import MinerConfigValue
 
 

pyasic/data/__init__.py

@@ -24,9 +24,7 @@ from pyasic.config import MinerConfig
 from pyasic.config.mining import MiningModePowerTune
 from pyasic.data.pools import PoolMetrics, Scheme
 from pyasic.device.algorithm.hashrate import AlgoHashRateType
-from pyasic.device.algorithm.hashrate.base import GenericHashrate
 
-from ..device.algorithm.hashrate.unit.base import GenericUnit
 from .boards import HashBoard
 from .device import DeviceInfo
 from .error_codes import BraiinsOSError, InnosiliconError, WhatsminerError, X19Error

pyasic/data/boards.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from pydantic import BaseModel, field_serializer
+from pydantic import BaseModel
 
 from pyasic.device.algorithm.hashrate import AlgoHashRateType
 

pyasic/data/error_codes/__init__.py

@@ -18,9 +18,15 @@ from typing import TypeVar
 
 from .bos import BraiinsOSError
 from .innosilicon import InnosiliconError
+from .vnish import VnishError
 from .whatsminer import WhatsminerError
 from .X19 import X19Error
 
 MinerErrorData = TypeVar(
-    "MinerErrorData", WhatsminerError, BraiinsOSError, X19Error, InnosiliconError
+    "MinerErrorData",
+    WhatsminerError,
+    BraiinsOSError,
+    X19Error,
+    InnosiliconError,
+    VnishError,
 )

pyasic/data/error_codes/vnish.py

@@ -0,0 +1,28 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 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.data.error_codes.base import BaseMinerError
+
+
+class VnishError(BaseMinerError):
+    """A Dataclass to handle error codes of Vnish miners.
+
+    Attributes:
+        error_message: The error message as a string.
+        error_code: The error code as an int.  0 if the message is not assigned a code.
+    """
+
+    error_message: str
+    error_code: int = 0

pyasic/device/makes.py

@@ -30,6 +30,7 @@ class MinerMake(str, Enum):
     ICERIVER = "IceRiver"
     HAMMER = "Hammer"
     VOLCMINER = "VolcMiner"
+    ELPHAPEX = "Elphapex"
     BRAIINS = "Braiins"
 
     def __str__(self):

pyasic/device/models.py

@@ -509,7 +509,8 @@ class BitAxeModels(MinerModelType):
 
 
 class LuckyMinerModels(MinerModelType):
-    BM1366 = "LV08"
+    LV07 = "LV07"
+    LV08 = "LV08"
 
     def __str__(self):
         return self.value
@@ -549,6 +550,10 @@ class BraiinsModels(MinerModelType):
     BMM101 = "BMM101"
 
 
+class ElphapexModels(MinerModelType):
+    DG1Plus = "DG1+"
+
+
 class MinerModel:
     ANTMINER = AntminerModels
     WHATSMINER = WhatsminerModels
@@ -562,4 +567,5 @@ class MinerModel:
     ICERIVER = IceRiverModels
     HAMMER = HammerModels
     VOLCMINER = VolcMinerModels
+    ELPHAPEX = ElphapexModels
     BRAIINS = BraiinsModels

pyasic/miners/antminer/hiveon/X19/S19.py

@@ -27,6 +27,7 @@ from pyasic.miners.device.models import (
     S19jNoPIC,
     S19jPro,
     S19KPro,
+    S19NoPIC,
     S19Plus,
     S19Pro,
     S19ProHydro,
@@ -39,6 +40,10 @@ class HiveonS19(HiveonModern, S19):
     pass
 
 
+class HiveonS19NoPIC(HiveonModern, S19NoPIC):
+    pass
+
+
 class HiveonS19Plus(HiveonModern, S19Plus):
     pass
 

pyasic/miners/antminer/hiveon/X19/__init__.py

@@ -25,6 +25,7 @@ from .S19 import (
     HiveonS19jPro,
     HiveonS19KPro,
     HiveonS19L,
+    HiveonS19NoPIC,
     HiveonS19Plus,
     HiveonS19Pro,
     HiveonS19ProHydro,

pyasic/miners/antminer/hiveon/X9/T9.py

@@ -16,8 +16,6 @@
 
 from typing import List, Optional
 
-import asyncssh
-
 from pyasic.data import HashBoard
 from pyasic.device.algorithm import AlgoHashRate, HashUnit
 from pyasic.errors import APIError

pyasic/miners/avalonminer/cgminer/nano/nano3.py

@@ -13,10 +13,91 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+from typing import Optional
 
+from pyasic import APIError
 from pyasic.miners.backends import AvalonMiner
+from pyasic.miners.data import (
+    DataFunction,
+    DataLocations,
+    DataOptions,
+    RPCAPICommand,
+    WebAPICommand,
+)
 from pyasic.miners.device.models import AvalonNano3
+from pyasic.web.avalonminer import AvalonMinerWebAPI
+
+AVALON_NANO_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_minerinfo", "get_minerinfo")],
+        ),
+        str(DataOptions.API_VERSION): DataFunction(
+            "_get_api_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.FW_VERSION): DataFunction(
+            "_get_fw_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.HASHRATE): DataFunction(
+            "_get_hashrate",
+            [RPCAPICommand("rpc_devs", "devs")],
+        ),
+        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
+            "_get_expected_hashrate",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
+            "_get_env_temp",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.WATTAGE_LIMIT): DataFunction(
+            "_get_wattage_limit",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
+    }
+)
 
 
 class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
-    pass
+    _web_cls = AvalonMinerWebAPI
+    web: AvalonMinerWebAPI
+
+    data_locations = AVALON_NANO_DATA_LOC
+
+    async def _get_mac(self, web_minerinfo: dict) -> Optional[dict]:
+        if web_minerinfo is None:
+            try:
+                web_minerinfo = await self.web.minerinfo()
+            except APIError:
+                pass
+
+        if web_minerinfo is not None:
+            try:
+                mac = web_minerinfo.get("mac")
+                if mac is not None:
+                    return mac.upper()
+            except (KeyError, ValueError):
+                pass

pyasic/miners/backends/__init__.py

@@ -22,6 +22,7 @@ from .bmminer import BMMiner
 from .braiins_os import BOSer, BOSMiner
 from .btminer import BTMiner
 from .cgminer import CGMiner
+from .elphapex import ElphapexMiner
 from .epic import ePIC
 from .goldshell import GoldshellMiner
 from .hammer import BlackMiner

pyasic/miners/backends/antminer.py

@@ -75,6 +75,10 @@ ANTMINER_MODERN_DATA_LOC = DataLocations(
             "_get_fault_light",
             [WebAPICommand("web_get_blink_status", "get_blink_status")],
         ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [],
+        ),
         str(DataOptions.IS_MINING): DataFunction(
             "_is_mining",
             [WebAPICommand("web_get_conf", "get_miner_conf")],

pyasic/miners/backends/elphapex.py

@@ -0,0 +1,319 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 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 import APIError
+from pyasic.data import Fan, HashBoard, X19Error
+from pyasic.data.error_codes import MinerErrorData
+from pyasic.device.algorithm import AlgoHashRate
+from pyasic.miners.data import (
+    DataFunction,
+    DataLocations,
+    DataOptions,
+    WebAPICommand,
+)
+from pyasic.miners.device.firmware import StockFirmware
+from pyasic.web.elphapex import ElphapexWebAPI
+
+ELPHAPEX_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_get_system_info", "get_system_info")],
+        ),
+        str(DataOptions.API_VERSION): DataFunction(
+            "_get_api_ver",
+            [WebAPICommand("web_summary", "summary")],
+        ),
+        str(DataOptions.FW_VERSION): DataFunction(
+            "_get_fw_ver",
+            [WebAPICommand("web_get_system_info", "get_system_info")],
+        ),
+        str(DataOptions.HOSTNAME): DataFunction(
+            "_get_hostname",
+            [WebAPICommand("web_get_system_info", "get_system_info")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [WebAPICommand("web_stats", "stats")],
+        ),
+        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
+            "_get_expected_hashrate",
+            [WebAPICommand("web_stats", "stats")],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [WebAPICommand("web_stats", "stats")],
+        ),
+        str(DataOptions.ERRORS): DataFunction(
+            "_get_errors",
+            [WebAPICommand("web_summary", "summary")],
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light",
+            [WebAPICommand("web_get_blink_status", "get_blink_status")],
+        ),
+        str(DataOptions.IS_MINING): DataFunction(
+            "_is_mining",
+            [WebAPICommand("web_get_miner_conf", "get_miner_conf")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [WebAPICommand("web_summary", "summary")],
+        ),
+    }
+)
+
+
+class ElphapexMiner(StockFirmware):
+    """Handler for Elphapex miners."""
+
+    _web_cls = ElphapexWebAPI
+    web: ElphapexWebAPI
+
+    data_locations = ELPHAPEX_DATA_LOC
+
+    async def fault_light_on(self) -> bool:
+        data = await self.web.blink(blink=True)
+        if data:
+            if data.get("code") == "B000":
+                self.light = True
+        return self.light
+
+    async def fault_light_off(self) -> bool:
+        data = await self.web.blink(blink=False)
+        if data:
+            if data.get("code") == "B100":
+                self.light = False
+        return self.light
+
+    async def reboot(self) -> bool:
+        data = await self.web.reboot()
+        if data:
+            return True
+        return False
+
+    async def _get_api_ver(self, web_summary: dict = None) -> Optional[str]:
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                pass
+
+        if web_summary is not None:
+            try:
+                self.api_ver = web_summary["STATUS"]["api_version"]
+            except LookupError:
+                pass
+
+        return self.api_ver
+
+    async def _get_fw_ver(self, web_get_system_info: dict = None) -> Optional[str]:
+        if web_get_system_info is None:
+            try:
+                web_get_system_info = await self.web.get_system_info()
+            except APIError:
+                pass
+
+        if web_get_system_info is not None:
+            try:
+                self.fw_ver = (
+                    web_get_system_info["system_filesystem_version"]
+                    .upper()
+                    .split("V")[-1]
+                )
+            except LookupError:
+                pass
+
+        return self.fw_ver
+
+    async def _get_hostname(self, web_get_system_info: dict = None) -> Optional[str]:
+        if web_get_system_info is None:
+            try:
+                web_get_system_info = await self.web.get_system_info()
+            except APIError:
+                pass
+
+        if web_get_system_info is not None:
+            try:
+                return web_get_system_info["hostname"]
+            except KeyError:
+                pass
+
+    async def _get_mac(self, web_get_system_info: dict = None) -> Optional[str]:
+        if web_get_system_info is None:
+            try:
+                web_get_system_info = await self.web.get_system_info()
+            except APIError:
+                pass
+
+        if web_get_system_info is not None:
+            try:
+                return web_get_system_info["macaddr"]
+            except KeyError:
+                pass
+
+        try:
+            data = await self.web.get_network_info()
+            if data:
+                return data["macaddr"]
+        except KeyError:
+            pass
+
+    async def _get_errors(self, web_summary: dict = None) -> List[MinerErrorData]:
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                pass
+
+        errors = []
+        if web_summary is not None:
+            try:
+                for item in web_summary["SUMMARY"][0]["status"]:
+                    try:
+                        if not item["status"] == "s":
+                            errors.append(X19Error(error_message=item["msg"]))
+                    except KeyError:
+                        continue
+            except LookupError:
+                pass
+        return errors
+
+    async def _get_hashboards(self, web_stats: dict | None = None) -> List[HashBoard]:
+        hashboards = [
+            HashBoard(slot=idx, expected_chips=self.expected_chips)
+            for idx in range(self.expected_hashboards)
+        ]
+
+        if web_stats is None:
+            try:
+                web_stats = await self.web.stats()
+            except APIError:
+                return hashboards
+
+        if web_stats is not None:
+            try:
+                for board in web_stats["STATS"][0]["chain"]:
+                    hashboards[board["index"]].hashrate = self.algo.hashrate(
+                        rate=board["rate_real"], unit=self.algo.unit.MH
+                    ).into(self.algo.unit.default)
+                    hashboards[board["index"]].chips = board["asic_num"]
+                    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
+                    )
+                    chip_temp_data = list(
+                        filter(lambda x: not x == "", board["temp_chip"])
+                    )
+                    hashboards[board["index"]].chip_temp = sum(
+                        [int(i) / 1000 for i in chip_temp_data]
+                    ) / len(chip_temp_data)
+                    hashboards[board["index"]].serial_number = board["sn"]
+                    hashboards[board["index"]].missing = False
+            except LookupError:
+                pass
+        return hashboards
+
+    async def _get_fault_light(
+        self, web_get_blink_status: dict = None
+    ) -> Optional[bool]:
+        if self.light:
+            return self.light
+
+        if web_get_blink_status is None:
+            try:
+                web_get_blink_status = await self.web.get_blink_status()
+            except APIError:
+                pass
+
+        if web_get_blink_status is not None:
+            try:
+                self.light = web_get_blink_status["blink"]
+            except KeyError:
+                pass
+        return self.light
+
+    async def _get_expected_hashrate(
+        self, web_stats: dict = None
+    ) -> Optional[AlgoHashRate]:
+        if web_stats is None:
+            try:
+                web_stats = await self.web.stats()
+            except APIError:
+                pass
+
+        if web_stats is not None:
+            try:
+                expected_rate = web_stats["STATS"][1]["total_rateideal"]
+                try:
+                    rate_unit = web_stats["STATS"][1]["rate_unit"]
+                except KeyError:
+                    rate_unit = "MH"
+                return self.algo.hashrate(
+                    rate=float(expected_rate), unit=self.algo.unit.from_str(rate_unit)
+                ).into(self.algo.unit.default)
+            except LookupError:
+                pass
+
+    async def _is_mining(self, web_get_miner_conf: dict = None) -> Optional[bool]:
+        if web_get_miner_conf is None:
+            try:
+                web_get_miner_conf = await self.web.get_miner_conf()
+            except APIError:
+                pass
+
+        if web_get_miner_conf is not None:
+            try:
+                if str(web_get_miner_conf["fc-work-mode"]).isdigit():
+                    return (
+                        False if int(web_get_miner_conf["fc-work-mode"]) == 1 else True
+                    )
+                return False
+            except LookupError:
+                pass
+
+    async def _get_uptime(self, web_summary: dict = None) -> Optional[int]:
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                pass
+
+        if web_summary is not None:
+            try:
+                return int(web_summary["SUMMARY"][1]["elapsed"])
+            except LookupError:
+                pass
+
+    async def _get_fans(self, web_stats: dict = None) -> List[Fan]:
+        if web_stats is None:
+            try:
+                web_stats = await self.web.stats()
+            except APIError:
+                pass
+
+        fans = [Fan() for _ in range(self.expected_fans)]
+        if web_stats is not None:
+            for fan_n in range(self.expected_fans):
+                try:
+                    fans[fan_n].speed = int(web_stats["STATS"][0]["fan"][fan_n])
+                except LookupError:
+                    pass
+
+        return fans

pyasic/miners/backends/vnish.py

@@ -15,9 +15,10 @@
 # ------------------------------------------------------------------------------
 
 import logging
-from typing import Optional
+from typing import List, Optional
 
 from pyasic import MinerConfig
+from pyasic.data.error_codes import MinerErrorData, VnishError
 from pyasic.device.algorithm import AlgoHashRate
 from pyasic.errors import APIError
 from pyasic.miners.backends.bmminer import BMMiner
@@ -85,6 +86,10 @@ VNISH_DATA_LOC = DataLocations(
             "_get_pools",
             [RPCAPICommand("rpc_pools", "pools")],
         ),
+        str(DataOptions.ERRORS): DataFunction(
+            "_get_errors",
+            [WebAPICommand("web_summary", "summary")],
+        ),
     }
 )
 
@@ -266,6 +271,24 @@ class VNish(VNishFirmware, BMMiner):
             except LookupError:
                 pass
 
+    async def _get_errors(self, web_summary: dict = None) -> List[MinerErrorData]:
+        errors = []
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                return errors
+
+        if web_summary is not None:
+            chains = web_summary.get("miner", {}).get("chains", [])
+            for chain in chains:
+                state = chain.get("status", {}).get("state")
+                description = chain.get("status", {}).get("description", "")
+                if state == "failure":
+                    errors.append(VnishError(error_message=description))
+
+        return errors
+
     async def get_config(self) -> MinerConfig:
         try:
             web_settings = await self.web.settings()

pyasic/miners/device/makes.py

@@ -68,3 +68,7 @@ class VolcMinerMake(BaseMiner):
 
 class BraiinsMake(BaseMiner):
     make = MinerMake.BRAIINS
+
+
+class ElphapexMake(BaseMiner):
+    make = MinerMake.ELPHAPEX

pyasic/miners/device/models/__init__.py

@@ -18,6 +18,7 @@ from .antminer import *
 from .auradine import *
 from .avalonminer import *
 from .braiins import *
+from .elphapex import *
 from .epic import *
 from .goldshell import *
 from .hammer import *

pyasic/miners/device/models/elphapex/DGX/DG1.py

@@ -0,0 +1,27 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2024 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 ElphapexMake
+
+
+class DG1Plus(ElphapexMake):
+    raw_model = MinerModel.ELPHAPEX.DG1Plus
+
+    expected_chips = 204
+    expected_hashboards = 4
+    expected_fans = 4
+    algo = MinerAlgo.SCRYPT

pyasic/miners/device/models/elphapex/DGX/__init__.py

@@ -0,0 +1 @@
+from .DG1 import DG1Plus

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

@@ -0,0 +1 @@
+from .DGX import *

pyasic/miners/device/models/luckyminer/LV/LV07.py

@@ -0,0 +1,12 @@
+from pyasic.device.algorithm import MinerAlgo
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import LuckyMinerMake
+
+
+class LV07(LuckyMinerMake):
+    raw_model = MinerModel.LUCKYMINER.LV07
+
+    expected_hashboards = 1
+    expected_chips = 1
+    expected_fans = 1
+    algo = MinerAlgo.SHA256

pyasic/miners/device/models/luckyminer/LV/LV08.py

@@ -4,7 +4,7 @@ from pyasic.miners.device.makes import LuckyMinerMake
 
 
 class LV08(LuckyMinerMake):
-    raw_model = MinerModel.LUCKYMINER.BM1366
+    raw_model = MinerModel.LUCKYMINER.LV08
 
     expected_hashboards = 1
     expected_chips = 1

pyasic/miners/device/models/luckyminer/LV/__init__.py

@@ -1 +1,2 @@
+from .LV07 import LV07
 from .LV08 import LV08

pyasic/miners/elphapex/__init__.py

@@ -0,0 +1 @@
+from .daoge import *

pyasic/miners/elphapex/daoge/DGX/DG1.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.elphapex import ElphapexMiner
+from pyasic.miners.device.models import DG1Plus
+
+
+class ElphapexDG1Plus(ElphapexMiner, DG1Plus):
+    pass

pyasic/miners/elphapex/daoge/DGX/__init__.py

@@ -0,0 +1 @@
+from .DG1 import ElphapexDG1Plus

pyasic/miners/elphapex/daoge/__init__.py

@@ -0,0 +1 @@
+from .DGX import *

pyasic/miners/factory.py

@@ -37,6 +37,7 @@ from pyasic.miners.bitaxe import *
 from pyasic.miners.blockminer import *
 from pyasic.miners.braiins import *
 from pyasic.miners.device.makes import *
+from pyasic.miners.elphapex import *
 from pyasic.miners.goldshell import *
 from pyasic.miners.hammer import *
 from pyasic.miners.iceriver import *
@@ -64,6 +65,7 @@ class MinerTypes(enum.Enum):
     HAMMER = 14
     VOLCMINER = 15
     LUCKYMINER = 16
+    ELPHAPEX = 17
 
 
 MINER_CLASSES = {
@@ -596,6 +598,7 @@ MINER_CLASSES = {
         "ANTMINER T9": HiveonT9,
         "ANTMINER S19JPRO": HiveonS19jPro,
         "ANTMINER S19": HiveonS19,
+        "ANTMINER S19X88": HiveonS19NoPIC,
     },
     MinerTypes.LUX_OS: {
         None: LUXMiner,
@@ -640,7 +643,8 @@ MINER_CLASSES = {
     },
     MinerTypes.LUCKYMINER: {
         None: LuckyMiner,
-        "BM1366": LuckyMinerLV08,
+        "LV08": LuckyMinerLV08,
+        "LV07": LuckyMinerLV07,
     },
     MinerTypes.ICERIVER: {
         None: type("IceRiverUnknown", (IceRiver, IceRiverMake), {}),
@@ -662,6 +666,10 @@ MINER_CLASSES = {
         None: type("VolcMinerUnknown", (BlackMiner, VolcMinerMake), {}),
         "VOLCMINER D1": VolcMinerD1,
     },
+    MinerTypes.ELPHAPEX: {
+        None: type("ElphapexUnknown", (ElphapexMiner, ElphapexMake), {}),
+        "DG1+": ElphapexDG1Plus,
+    },
 }
 
 
@@ -743,6 +751,7 @@ class MinerFactory:
                 MinerTypes.ICERIVER: self.get_miner_model_iceriver,
                 MinerTypes.HAMMER: self.get_miner_model_hammer,
                 MinerTypes.VOLCMINER: self.get_miner_model_volcminer,
+                MinerTypes.ELPHAPEX: self.get_miner_model_elphapex,
             }
             fn = miner_model_fns.get(miner_type)
 
@@ -826,6 +835,10 @@ class MinerFactory:
             "www-authenticate", ""
         ):
             return MinerTypes.HAMMER
+        if web_resp.status_code == 401 and 'realm="Daoge' in web_resp.headers.get(
+            "www-authenticate", ""
+        ):
+            return MinerTypes.ELPHAPEX
         if len(web_resp.history) > 0:
             history_resp = web_resp.history[0]
             if (
@@ -1311,7 +1324,7 @@ class MinerFactory:
         web_json_data = await self.send_web_command(ip, "/api/system/info")
 
         try:
-            miner_model = web_json_data["ASICModel"]
+            miner_model = web_json_data["minerModel"]
             if miner_model == "":
                 return None
 
@@ -1382,6 +1395,21 @@ class MinerFactory:
         except (TypeError, LookupError):
             pass
 
+    async def get_miner_model_elphapex(self, ip: str) -> str | None:
+        auth = httpx.DigestAuth(
+            "root", settings.get("default_elphapex_web_password", "root")
+        )
+        web_json_data = await self.send_web_command(
+            ip, "/cgi-bin/get_system_info.cgi", auth=auth
+        )
+
+        try:
+            miner_model = web_json_data["minertype"]
+
+            return miner_model
+        except (TypeError, LookupError):
+            pass
+
 
 miner_factory = MinerFactory()
 

pyasic/miners/luckyminer/espminer/LV/LV07.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.luckyminer import LuckyMiner
+from pyasic.miners.device.models.luckyminer import LV07
+
+
+class LuckyMinerLV07(LuckyMiner, LV07):
+    pass

pyasic/miners/luckyminer/espminer/LV/__init__.py

@@ -1 +1,2 @@
+from .LV07 import LuckyMinerLV07
 from .LV08 import LuckyMinerLV08

pyasic/settings/__init__.py

@@ -40,6 +40,7 @@ _settings = {  # defaults
     "default_epic_web_password": "letmein",
     "default_hive_web_password": "root",
     "default_iceriver_web_password": "12345678",
+    "default_elphapex_web_password": "root",
     "default_antminer_ssh_password": "miner",
     "default_bosminer_ssh_password": "root",
 }

pyasic/web/avalonminer.py

@@ -0,0 +1,108 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 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 __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+from typing import Any
+
+import httpx
+
+from pyasic import settings
+from pyasic.web.base import BaseWebAPI
+
+
+class AvalonMinerWebAPI(BaseWebAPI):
+    def __init__(self, ip: str) -> None:
+        """Initialize the modern Avalonminer API client with a specific IP address.
+
+        Args:
+            ip (str): IP address of the Avalonminer device.
+        """
+        super().__init__(ip)
+        self.username = "root"
+        self.pwd = settings.get("default_avalonminer_web_password", "root")
+
+    async def send_command(
+        self,
+        command: str | bytes,
+        ignore_errors: bool = False,
+        allow_warning: bool = True,
+        **parameters: Any,
+    ) -> dict:
+        """Send a command to the Avalonminer device using HTTP digest authentication.
+
+        Args:
+            command (str | bytes): The CGI command to send.
+            ignore_errors (bool): If True, ignore any HTTP errors.
+            allow_warning (bool): If True, proceed with warnings.
+            **parameters: Arbitrary keyword arguments to be sent as parameters in the request.
+
+        Returns:
+            dict: The JSON response from the device or an empty dictionary if an error occurs.
+        """
+        cookie_data = "ff0000ff" + hashlib.sha256(self.pwd.encode()).hexdigest()[:24]
+
+        url = f"http://{self.ip}:{self.port}/{command}.cgi"
+        try:
+            async with httpx.AsyncClient(transport=settings.transport()) as client:
+                client.cookies.set("auth", cookie_data)
+                resp = await client.get(url)
+                raw_data = resp.text.replace("minerinfoCallback(", "").replace(");", "")
+                return json.loads(raw_data)
+        except httpx.HTTPError:
+            pass
+        return {}
+
+    async def multicommand(
+        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
+    ) -> dict:
+        async with httpx.AsyncClient(transport=settings.transport()) as client:
+            cookie_data = (
+                "ff0000ff" + hashlib.sha256(self.pwd.encode()).hexdigest()[:24]
+            )
+            client.cookies.set("auth", cookie_data)
+            tasks = [
+                asyncio.create_task(self._handle_multicommand(client, command))
+                for command in commands
+            ]
+            all_data = await asyncio.gather(*tasks)
+
+        data = {}
+        for item in all_data:
+            data.update(item)
+
+        data["multicommand"] = True
+        return data
+
+    async def _handle_multicommand(
+        self, client: httpx.AsyncClient, command: str
+    ) -> dict:
+        try:
+            url = f"http://{self.ip}:{self.port}/{command}.cgi"
+            resp = await client.get(url)
+            raw_data = resp.text.replace("minerinfoCallback(", "").replace(");", "")
+            return json.loads(raw_data)
+        except httpx.HTTPError:
+            pass
+        return {}
+
+    async def minerinfo(self):
+        return await self.send_command("get_minerinfo")
+
+    async def home(self):
+        return await self.send_command("get_home")

pyasic/web/elphapex.py

@@ -0,0 +1,216 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 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 __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+import httpx
+
+from pyasic import settings
+from pyasic.web.base import BaseWebAPI
+
+
+class ElphapexWebAPI(BaseWebAPI):
+    def __init__(self, ip: str) -> None:
+        """Initialize the modern Elphapex API client with a specific IP address.
+
+        Args:
+            ip (str): IP address of the Elphapex device.
+        """
+        super().__init__(ip)
+        self.username = "root"
+        self.pwd = settings.get("default_elphapex_web_password", "root")
+
+    async def send_command(
+        self,
+        command: str | bytes,
+        ignore_errors: bool = False,
+        allow_warning: bool = True,
+        privileged: bool = False,
+        **parameters: Any,
+    ) -> dict:
+        """Send a command to the Elphapex device using HTTP digest authentication.
+
+        Args:
+            command (str | bytes): The CGI command to send.
+            ignore_errors (bool): If True, ignore any HTTP errors.
+            allow_warning (bool): If True, proceed with warnings.
+            privileged (bool): If set to True, requires elevated privileges.
+            **parameters: Arbitrary keyword arguments to be sent as parameters in the request.
+
+        Returns:
+            dict: The JSON response from the device or an empty dictionary if an error occurs.
+        """
+        url = f"http://{self.ip}:{self.port}/cgi-bin/{command}.cgi"
+        auth = httpx.DigestAuth(self.username, self.pwd)
+        try:
+            async with httpx.AsyncClient(transport=settings.transport()) as client:
+
+                if parameters:
+                    data = await client.post(
+                        url,
+                        auth=auth,
+                        timeout=settings.get("api_function_timeout", 3),
+                        json=parameters,
+                    )
+                else:
+                    data = await client.get(url, auth=auth)
+        except httpx.HTTPError as e:
+            return {"success": False, "message": f"HTTP error occurred: {str(e)}"}
+        else:
+            if data.status_code == 200:
+                try:
+                    return data.json()
+                except json.decoder.JSONDecodeError:
+                    return {"success": False, "message": "Failed to decode JSON"}
+        return {"success": False, "message": "Unknown error occurred"}
+
+    async def multicommand(
+        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
+    ) -> dict:
+        """Execute multiple commands simultaneously.
+
+        Args:
+            *commands (str): Multiple command strings to be executed.
+            ignore_errors (bool): If True, ignore any HTTP errors.
+            allow_warning (bool): If True, proceed with warnings.
+
+        Returns:
+            dict: A dictionary containing the results of all commands executed.
+        """
+        async with httpx.AsyncClient(transport=settings.transport()) as client:
+            tasks = [
+                asyncio.create_task(self._handle_multicommand(client, command))
+                for command in commands
+            ]
+            all_data = await asyncio.gather(*tasks)
+
+        data = {}
+        for item in all_data:
+            data.update(item)
+
+        data["multicommand"] = True
+        return data
+
+    async def _handle_multicommand(
+        self, client: httpx.AsyncClient, command: str
+    ) -> dict:
+        """Helper function for handling individual commands in a multicommand execution.
+
+        Args:
+            client (httpx.AsyncClient): The HTTP client to use for the request.
+            command (str): The command to be executed.
+
+        Returns:
+            dict: A dictionary containing the response of the executed command.
+        """
+        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
+        return {command: {}}
+
+    async def get_miner_conf(self) -> dict:
+        """Retrieve the miner configuration from the Elphapex device.
+
+        Returns:
+            dict: A dictionary containing the current configuration of the miner.
+        """
+        return await self.send_command("get_miner_conf")
+
+    async def set_miner_conf(self, conf: dict) -> dict:
+        """Set the configuration for the miner.
+
+        Args:
+            conf (dict): A dictionary of configuration settings to apply to the miner.
+
+        Returns:
+            dict: A dictionary response from the device after setting the configuration.
+        """
+        return await self.send_command("set_miner_conf", **conf)
+
+    async def blink(self, blink: bool) -> dict:
+        """Control the blinking of the LED on the miner device.
+
+        Args:
+            blink (bool): True to start blinking, False to stop.
+
+        Returns:
+            dict: A dictionary response from the device after the command execution.
+        """
+        if blink:
+            return await self.send_command("blink", blink="true")
+        return await self.send_command("blink", blink="false")
+
+    async def reboot(self) -> dict:
+        """Reboot the miner device.
+
+        Returns:
+            dict: A dictionary response from the device confirming the reboot command.
+        """
+        return await self.send_command("reboot")
+
+    async def get_system_info(self) -> dict:
+        """Retrieve system information from the miner.
+
+        Returns:
+            dict: A dictionary containing system information of the miner.
+        """
+        return await self.send_command("get_system_info")
+
+    async def get_network_info(self) -> dict:
+        """Retrieve network configuration information from the miner.
+
+        Returns:
+            dict: A dictionary containing the network configuration of the miner.
+        """
+        return await self.send_command("get_network_info")
+
+    async def summary(self) -> dict:
+        """Get a summary of the miner's status and performance.
+
+        Returns:
+            dict: A summary of the miner's current operational status.
+        """
+        return await self.send_command("summary")
+
+    async def stats(self) -> dict:
+        """Get miners stats.
+
+        Returns:
+            dict: A summary of the miner's current operational status.
+        """
+        return await self.send_command("stats")
+
+    async def get_blink_status(self) -> dict:
+        """Check the status of the LED blinking on the miner.
+
+        Returns:
+            dict: A dictionary indicating whether the LED is currently blinking.
+        """
+        return await self.send_command("get_blink_status")

pyasic/web/hiveon.py

@@ -15,7 +15,6 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-import asyncio
 import json
 from pathlib import Path
 from typing import Any

pyproject.toml

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

tests/__init__.py

@@ -15,7 +15,7 @@
 # ------------------------------------------------------------------------------
 
 from tests.config_tests import TestConfig
-from tests.miners_tests import MinersTest, TestHammerMiners
+from tests.miners_tests import MinersTest, TestElphapexMiners, TestHammerMiners
 from tests.network_tests import NetworkTest
 from tests.rpc_tests import *
 

tests/miners_tests/backends_tests/__init__.py

@@ -1 +1,2 @@
+from .alphapex_tests import *
 from .hammer_tests import *

tests/miners_tests/backends_tests/alphapex_tests/__init__.py

@@ -0,0 +1 @@
+from .version_1_0_2 import TestElphapexMiners

tests/miners_tests/backends_tests/alphapex_tests/version_1_0_2.py

@@ -0,0 +1,242 @@
+"""Tests for hammer miners with firmware dating 2023-05-28 17-20-35 CST"""
+
+import unittest
+from dataclasses import fields
+from unittest.mock import patch
+
+from pyasic import APIError, MinerData
+from pyasic.data import Fan, HashBoard
+from pyasic.device.algorithm.hashrate.unit.scrypt import ScryptUnit
+from pyasic.miners.elphapex import ElphapexDG1Plus
+
+data = {
+    ElphapexDG1Plus: {
+        "web_get_system_info": {
+            "ipaddress": "172.19.203.183",
+            "system_mode": "GNU/Linux",
+            "netmask": "255.255.255.0",
+            "gateway": "",
+            "Algorithm": "Scrypt",
+            "system_kernel_version": "4.4.194 #1 SMP Sat Sep 7 16:59:20 CST 2024",
+            "system_filesystem_version": "DG1+_SW_V1.0.2",
+            "nettype": "DHCP",
+            "dnsservers": "",
+            "netdevice": "eth0",
+            "minertype": "DG1+",
+            "macaddr": "12:34:56:78:90:12",
+            "firmware_type": "Release",
+            "hostname": "DG1+",
+        },
+        "web_summary": {
+            "STATUS": {
+                "STATUS": "S",
+                "when": 2557706,
+                "timestamp": 1731569527,
+                "api_version": "1.0.0",
+                "Msg": "summary",
+            },
+            "SUMMARY": [
+                {
+                    "rate_unit": "MH/s",
+                    "elapsed": 357357,
+                    "rate_30m": 0,
+                    "rate_5s": 14920.940000000001,
+                    "bestshare": 0,
+                    "rate_ideal": 14229,
+                    "status": [
+                        {"status": "s", "type": "rate", "msg": "", "code": 0},
+                        {"status": "s", "type": "network", "msg": "", "code": 0},
+                        {"status": "s", "type": "fans", "msg": "", "code": 0},
+                        {"status": "s", "type": "temp", "msg": "", "code": 0},
+                    ],
+                    "hw_all": 14199.040000000001,
+                    "rate_avg": 14199.040000000001,
+                    "rate_15m": 14415,
+                }
+            ],
+            "INFO": {
+                "miner_version": "DG1+_SW_V1.0.2",
+                "CompileTime": "",
+                "dev_sn": "28HY245192N000245C23B",
+                "type": "DG1+",
+                "hw_version": "DG1+_HW_V1.0",
+            },
+        },
+        "web_stats": {
+            "STATUS": {
+                "STATUS": "S",
+                "when": 2557700,
+                "timestamp": 1731569521,
+                "api_version": "1.0.0",
+                "Msg": "stats",
+            },
+            "INFO": {
+                "miner_version": "DG1+_SW_V1.0.2",
+                "CompileTime": "",
+                "dev_sn": "28HY245192N000245C23B",
+                "type": "DG1+",
+                "hw_version": "DG1+_HW_V1.0",
+            },
+            "STATS": [
+                {
+                    "rate_unit": "MH/s",
+                    "elapsed": 357352,
+                    "rate_30m": 0,
+                    "rate_5s": 11531.879999999999,
+                    "hwp_total": 0.11550000000000001,
+                    "rate_ideal": 14229,
+                    "chain": [
+                        {
+                            "freq_avg": 62000,
+                            "index": 0,
+                            "sn": "13HY245156N000581H11JB52",
+                            "temp_chip": ["47125", "50500", "", ""],
+                            "eeprom_loaded": True,
+                            "rate_15m": 3507,
+                            "hw": 204,
+                            "temp_pcb": [47, 46, 67, 66],
+                            "failrate": 0.029999999999999999,
+                            "asic": "ooooooooo oooooooo oooooooo oooooooo oooo",
+                            "rate_real": 3553.5,
+                            "asic_num": 204,
+                            "temp_pic": [47, 46, 67, 66],
+                            "rate_ideal": 3557.25,
+                            "hashrate": 3278.5999999999999,
+                        },
+                        {
+                            "freq_avg": 62000,
+                            "index": 1,
+                            "sn": "13HY245156N000579H11JB52",
+                            "temp_chip": ["52812", "56937", "", ""],
+                            "eeprom_loaded": True,
+                            "rate_15m": 3736,
+                            "hw": 204,
+                            "temp_pcb": [47, 46, 67, 66],
+                            "failrate": 0.02,
+                            "asic": "ooooooooo oooooooo oooooooo oooooooo oooo",
+                            "rate_real": 3550.1100000000001,
+                            "asic_num": 204,
+                            "temp_pic": [47, 46, 67, 66],
+                            "rate_ideal": 3557.25,
+                            "hashrate": 3491.8400000000001,
+                        },
+                        {
+                            "freq_avg": 62000,
+                            "index": 2,
+                            "sn": "13HY245156N000810H11JB52",
+                            "temp_chip": ["48312", "51687", "", ""],
+                            "eeprom_loaded": True,
+                            "rate_15m": 3531,
+                            "hw": 204,
+                            "temp_pcb": [47, 46, 67, 66],
+                            "failrate": 0.51000000000000001,
+                            "asic": "ooooooooo oooooooo oooooooo oooooooo oooo",
+                            "rate_real": 3551.8000000000002,
+                            "asic_num": 204,
+                            "temp_pic": [47, 46, 67, 66],
+                            "rate_ideal": 3557.25,
+                            "hashrate": 3408.6999999999998,
+                        },
+                        {
+                            "freq_avg": 62000,
+                            "index": 3,
+                            "sn": "13HY245156N000587H11JB52",
+                            "temp_chip": ["46500", "49062", "", ""],
+                            "eeprom_loaded": True,
+                            "rate_15m": 3641,
+                            "hw": 204,
+                            "temp_pcb": [47, 46, 67, 66],
+                            "failrate": 0.029999999999999999,
+                            "asic": "ooooooooo oooooooo oooooooo oooooooo oooo",
+                            "rate_real": 3543.6300000000001,
+                            "asic_num": 204,
+                            "temp_pic": [47, 46, 67, 66],
+                            "rate_ideal": 3557.25,
+                            "hashrate": 3463.6799999999998,
+                        },
+                    ],
+                    "rate_15m": 14415,
+                    "chain_num": 4,
+                    "fan": ["5340", "5400", "5400", "5400"],
+                    "rate_avg": 14199.040000000001,
+                    "fan_num": 4,
+                }
+            ],
+        },
+        "web_get_blink_status": {"blink": False},
+        "web_get_miner_conf": {
+            "pools": [
+                {
+                    "url": "stratum+tcp://ltc.trustpool.ru:3333",
+                    "pass": "123",
+                    "user": "Nikita9231.fworker",
+                },
+                {
+                    "url": "stratum+tcp://ltc.trustpool.ru:443",
+                    "pass": "123",
+                    "user": "Nikita9231.fworker",
+                },
+                {
+                    "url": "stratum+tcp://ltc.trustpool.ru:25",
+                    "pass": "123",
+                    "user": "Nikita9231.fworker",
+                },
+            ],
+            "fc-voltage": "1470",
+            "fc-fan-ctrl": False,
+            "fc-freq-level": "100",
+            "fc-fan-pwm": "80",
+            "algo": "ltc",
+            "fc-work-mode": 0,
+            "fc-freq": "1850",
+        },
+    }
+}
+
+
+class TestElphapexMiners(unittest.IsolatedAsyncioTestCase):
+    @patch("pyasic.rpc.base.BaseMinerRPCAPI._send_bytes")
+    async def test_all_data_gathering(self, mock_send_bytes):
+        mock_send_bytes.raises = APIError()
+        for m_type in data:
+            gathered_data = {}
+            miner = m_type("127.0.0.1")
+            for data_name in fields(miner.data_locations):
+                if data_name.name == "config":
+                    # skip
+                    continue
+                data_func = getattr(miner.data_locations, data_name.name)
+                fn_args = data_func.kwargs
+                args_to_send = {k.name: data[m_type][k.name] for k in fn_args}
+                function = getattr(miner, data_func.cmd)
+                gathered_data[data_name.name] = await function(**args_to_send)
+
+            result = MinerData(
+                ip=str(miner.ip),
+                device_info=miner.device_info,
+                expected_chips=(
+                    miner.expected_chips * miner.expected_hashboards
+                    if miner.expected_chips is not None
+                    else 0
+                ),
+                expected_hashboards=miner.expected_hashboards,
+                expected_fans=miner.expected_fans,
+                hashboards=[
+                    HashBoard(slot=i, expected_chips=miner.expected_chips)
+                    for i in range(miner.expected_hashboards)
+                ],
+            )
+            for item in gathered_data:
+                if gathered_data[item] is not None:
+                    setattr(result, item, gathered_data[item])
+
+            self.assertEqual(result.mac, "12:34:56:78:90:12")
+            self.assertEqual(result.api_ver, "1.0.0")
+            self.assertEqual(result.fw_ver, "1.0.2")
+            self.assertEqual(result.hostname, "DG1+")
+            self.assertEqual(round(result.hashrate.into(ScryptUnit.MH)), 14199)
+            self.assertEqual(
+                result.fans,
+                [Fan(speed=5340), Fan(speed=5400), Fan(speed=5400), Fan(speed=5400)],
+            )
+            self.assertEqual(result.total_chips, result.expected_chips)