version: bump version number

refactor: cleanup some imports
feature: add support for Elphapex DG1+
2025-02-04 16:00:18 -07:00 · 2025-02-04 15:59:32 -07:00 · 2025-02-04 15:59:32 -07:00 · 2025-02-03 09:39:49 -07:00 · 2025-02-03 09:39:30 -07:00 · 2025-02-03 09:32:44 -07:00
55 changed files with 1338 additions and 92 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,7 +1,8 @@
 ci:
  skip:
    - poetry-lock
-    - pytest
+    - unittest
+    - generate-docs
 repos:
 -   repo: https://github.com/python-poetry/poetry
    rev: 2.0.1
@@ -22,11 +23,11 @@ repos:
        exclude: ^mkdocs\.yml$
    -   id: check-added-large-files
 -   repo: https://github.com/psf/black
-    rev: 24.10.0
+    rev: 25.1.0
    hooks:
    -   id: black
 -   repo: https://github.com/pycqa/isort
-    rev: 5.13.2
+    rev: 6.0.0
    hooks:
    -   id: isort
        name: isort (python)
@@ -37,6 +38,12 @@ repos:
        name: unittest
        entry: python -m unittest discover
        language: system
-        'types': [python]
+        types: [ python ]
        args: ["-p '*test.py'"] # Probably this option is absolutely not needed.
        pass_filenames: false
+    -   id: generate-docs
+        name: generate-docs
+        entry: python docs/generate_miners.py
+        language: system
+        types: [ python ]
+        pass_filenames: false
--- a/docs/generate_miners.py
+++ b/docs/generate_miners.py
@@ -2,6 +2,7 @@ import asyncio
 import importlib
 import os
 import warnings
+from pathlib import Path

 from pyasic.miners.factory import MINER_CLASSES, MinerTypes

@@ -59,6 +60,9 @@ 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")


 def create_url_str(mtype: str):
@@ -137,14 +141,14 @@ for m in MINER_CLASSES:
            done.append(miner)


-async def create_directory_structure(directory, data):
+def create_directory_structure(directory, data):
    if not os.path.exists(directory):
        os.makedirs(directory)

    for key, value in data.items():
        subdirectory = os.path.join(directory, key)
        if isinstance(value, dict):
-            await create_directory_structure(subdirectory, value)
+            create_directory_structure(subdirectory, value)
        elif isinstance(value, list):
            file_path = os.path.join(subdirectory + ".md")

@@ -165,7 +169,7 @@ async def create_directory_structure(directory, data):
                    )


-async def create_supported_types(directory):
+def create_supported_types(directory):
    with open(os.path.join(directory, "supported_types.md"), "w") as file:
        file.write(SUPPORTED_TYPES_HEADER)
        for mback in MINER_CLASSES:
@@ -182,7 +186,7 @@ async def create_supported_types(directory):
            for mtype in backend_types:
                file.write(MINER_TYPE_HEADER.format(mtype))
                for minstance in backend_types[mtype]:
-                    model = await minstance("1.1.1.1").get_model()
+                    model = minstance("1.1.1.1").model
                    file.write(
                        MINER_DETAILS.format(
                            make(minstance), mtype, create_url_str(model), model
@@ -192,6 +196,7 @@ async def create_supported_types(directory):
            file.write(BACKEND_TYPE_CLOSER)


-root_directory = os.path.join(os.getcwd(), "miners")
-asyncio.run(create_directory_structure(root_directory, m_data))
-asyncio.run(create_supported_types(root_directory))
+if __name__ == "__main__":
+    root_directory = Path(__file__).parent.joinpath("miners")
+    create_directory_structure(root_directory, m_data)
+    create_supported_types(root_directory)
--- a/docs/miners/antminer/X19.md
+++ b/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
--- a/docs/miners/antminer/X21.md
+++ b/docs/miners/antminer/X21.md
@@ -14,6 +14,19 @@
        show_root_heading: false
        heading_level: 0

+## S21 Hydro (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21Hydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S21 Pro (Stock)

 - [x] Shutdowns
@@ -53,6 +66,19 @@
        show_root_heading: false
        heading_level: 0

+## S21 Pro (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## T21 (BOS+)

 - [x] Shutdowns
--- a/docs/miners/elphapex/DGX.md
+++ b/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
+
--- a/docs/miners/luckyminer/LV.md
+++ b/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
--- a/docs/miners/supported_types.md
+++ b/docs/miners/supported_types.md
@@ -105,6 +105,7 @@ details {
                    <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
                    <li><a href="../antminer/X21#s21-pro-stock">S21 Pro (Stock)</a></li>
                    <li><a href="../antminer/X21#t21-stock">T21 (Stock)</a></li>
+                    <li><a href="../antminer/X21#s21-hydro-stock">S21 Hydro (Stock)</a></li>
                </ul>
        </details>
    </ul>
@@ -652,6 +653,7 @@ details {
            <summary>X21 Series:</summary>
                <ul>
                    <li><a href="../antminer/X21#s21-bos_1">S21 (BOS+)</a></li>
+                    <li><a href="../antminer/X21#s21-pro-bos_1">S21 Pro (BOS+)</a></li>
                    <li><a href="../antminer/X21#t21-bos_1">T21 (BOS+)</a></li>
                </ul>
        </details>
@@ -761,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>
@@ -866,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>
@@ -910,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>
--- a/poetry.lock
+++ b/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]]
@@ -422,19 +422,19 @@ test = ["pytest (>=6)"]

 [[package]]
 name = "filelock"
-version = "3.16.1"
+version = "3.17.0"
 description = "A platform independent file lock."
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"},
-    {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"},
+    {file = "filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338"},
+    {file = "filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e"},
 ]

 [package.extras]
-docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"]
-testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"]
+docs = ["furo (>=2024.8.6)", "sphinx (>=8.1.3)", "sphinx-autodoc-typehints (>=3)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.6.10)", "diff-cover (>=9.2.1)", "pytest (>=8.3.4)", "pytest-asyncio (>=0.25.2)", "pytest-cov (>=6)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.28.1)"]
 typing = ["typing-extensions (>=4.12.2)"]

 [[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,30 +502,30 @@ 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"
-version = "4.0.0"
-description = "Pure-Python HPACK header compression"
+version = "4.1.0"
+description = "Pure-Python HPACK header encoding"
 optional = false
-python-versions = ">=3.6.1"
+python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "hpack-4.0.0-py3-none-any.whl", hash = "sha256:84a076fad3dc9a9f8063ccb8041ef100867b1878b25ef0ee63847a5d53818a6c"},
-    {file = "hpack-4.0.0.tar.gz", hash = "sha256:fc41de0c63e687ebffde81187a948221294896f6bdc0ae2312708df339430095"},
+    {file = "hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496"},
+    {file = "hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca"},
 ]

 [[package]]
@@ -577,26 +577,26 @@ zstd = ["zstandard (>=0.18.0)"]

 [[package]]
 name = "hyperframe"
-version = "6.0.1"
-description = "HTTP/2 framing layer for Python"
+version = "6.1.0"
+description = "Pure-Python HTTP/2 framing"
 optional = false
-python-versions = ">=3.6.1"
+python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "hyperframe-6.0.1-py3-none-any.whl", hash = "sha256:0ec6bafd80d8ad2195c4f03aacba3a8265e57bc4cff261e802bf39970ed02a15"},
-    {file = "hyperframe-6.0.1.tar.gz", hash = "sha256:ae510046231dc8e9ecb1a6586f63d2347bf4c8905914aa84ba585ae85f28a914"},
+    {file = "hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5"},
+    {file = "hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08"},
 ]

 [[package]]
 name = "identify"
-version = "2.6.5"
+version = "2.6.6"
 description = "File identification library for Python"
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "identify-2.6.5-py2.py3-none-any.whl", hash = "sha256:14181a47091eb75b337af4c23078c9d09225cd4c48929f521f3bf16b09d02566"},
-    {file = "identify-2.6.5.tar.gz", hash = "sha256:c10b33f250e5bba374fae86fb57f3adcebf1161bce7cdf92031915fd480c13bc"},
+    {file = "identify-2.6.6-py2.py3-none-any.whl", hash = "sha256:cbd1810bce79f8b671ecb20f53ee0ae8e86ae84b557de31d89709dc2a48ba881"},
+    {file = "identify-2.6.6.tar.gz", hash = "sha256:7bec12768ed44ea4761efb47806f0a41f86e7c0a5fdf5950d4648c90eca7e251"},
 ]

 [package.extras]
@@ -619,15 +619,15 @@ all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2

 [[package]]
 name = "importlib-metadata"
-version = "8.5.0"
+version = "8.6.1"
 description = "Read metadata from Python packages"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 groups = ["docs"]
 markers = "python_version < \"3.10\""
 files = [
-    {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"},
-    {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"},
+    {file = "importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e"},
+    {file = "importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580"},
 ]

 [package.dependencies]
@@ -639,7 +639,7 @@ cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 enabler = ["pytest-enabler (>=2.2)"]
 perf = ["ipython"]
-test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
+test = ["flufl.flake8", "importlib_resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
 type = ["pytest-mypy"]

 [[package]]
@@ -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]
@@ -1127,14 +1127,14 @@ type = ["mypy (>=1.11.2)"]

 [[package]]
 name = "pre-commit"
-version = "4.0.1"
+version = "4.1.0"
 description = "A framework for managing and maintaining multi-language pre-commit hooks."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "pre_commit-4.0.1-py2.py3-none-any.whl", hash = "sha256:efde913840816312445dc98787724647c65473daefe420785f885e8ed9a06878"},
-    {file = "pre_commit-4.0.1.tar.gz", hash = "sha256:80905ac375958c0444c65e9cebebd948b3cdb518f335a091a670a89d652139d2"},
+    {file = "pre_commit-4.1.0-py2.py3-none-any.whl", hash = "sha256:d29e7cb346295bcc1cc75fc3e92e343495e3ea0196c9ec6ba53f49f10ab6ae7b"},
+    {file = "pre_commit-4.1.0.tar.gz", hash = "sha256:ae3f018575a588e30dfddfab9a05448bfbd6b73d78709617b5a2b853549716d4"},
 ]

 [package.dependencies]
@@ -1177,14 +1177,14 @@ files = [

 [[package]]
 name = "pydantic"
-version = "2.10.5"
+version = "2.10.6"
 description = "Data validation using Python type hints"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
 files = [
-    {file = "pydantic-2.10.5-py3-none-any.whl", hash = "sha256:4dd4e322dbe55472cb7ca7e73f4b63574eecccf2835ffa2af9021ce113c83c53"},
-    {file = "pydantic-2.10.5.tar.gz", hash = "sha256:278b38dbbaec562011d659ee05f63346951b3a248a6f3642e1bc68894ea2b4ff"},
+    {file = "pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584"},
+    {file = "pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236"},
 ]

 [package.dependencies]
@@ -1326,14 +1326,14 @@ windows-terminal = ["colorama (>=0.4.6)"]

 [[package]]
 name = "pymdown-extensions"
-version = "10.14"
+version = "10.14.3"
 description = "Extension pack for Python Markdown."
 optional = false
 python-versions = ">=3.8"
 groups = ["docs"]
 files = [
-    {file = "pymdown_extensions-10.14-py3-none-any.whl", hash = "sha256:202481f716cc8250e4be8fce997781ebf7917701b59652458ee47f2401f818b5"},
-    {file = "pymdown_extensions-10.14.tar.gz", hash = "sha256:741bd7c4ff961ba40b7528d32284c53bc436b8b1645e8e37c3e57770b8700a34"},
+    {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]
@@ -1760,4 +1760,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">3.9, <4.0"
-content-hash = "6f5bcdfff0891ee60759be4a2ccb175049706e174b041fd2b33b1e85afd1edba"
+content-hash = "67a8e0d34c0d1af0f8e4d617d80fd5afc8d197e5d5444f78fd82e4f716a52965"
--- a/pyasic/config/mining/algo.py
+++ b/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
--- a/pyasic/config/mining/scaling.py
+++ b/pyasic/config/mining/scaling.py
@@ -15,8 +15,6 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations

-from dataclasses import dataclass
-
 from pyasic.config.base import MinerConfigValue


--- a/pyasic/config/temperature.py
+++ b/pyasic/config/temperature.py
@@ -15,8 +15,6 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations

-from dataclasses import dataclass
-
 from pyasic.config.base import MinerConfigValue


--- a/pyasic/data/init.py
+++ b/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
--- a/pyasic/data/boards.py
+++ b/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

--- a/pyasic/data/error_codes/init.py
+++ b/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,
 )
--- a/pyasic/data/error_codes/vnish.py
+++ b/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
--- a/pyasic/device/makes.py
+++ b/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):
--- a/pyasic/device/models.py
+++ b/pyasic/device/models.py
@@ -59,6 +59,7 @@ class AntminerModels(MinerModelType):
    T19 = "T19"
    S21 = "S21"
    S21Pro = "S21 Pro"
+    S21Hydro = "S21 Hydro"
    T21 = "T21"

    def __str__(self):
@@ -508,7 +509,8 @@ class BitAxeModels(MinerModelType):


 class LuckyMinerModels(MinerModelType):
-    BM1366 = "LV08"
+    LV07 = "LV07"
+    LV08 = "LV08"

    def __str__(self):
        return self.value
@@ -548,6 +550,10 @@ class BraiinsModels(MinerModelType):
    BMM101 = "BMM101"


+class ElphapexModels(MinerModelType):
+    DG1Plus = "DG1+"
+
+
 class MinerModel:
    ANTMINER = AntminerModels
    WHATSMINER = WhatsminerModels
@@ -561,4 +567,5 @@ class MinerModel:
    ICERIVER = IceRiverModels
    HAMMER = HammerModels
    VOLCMINER = VolcMinerModels
+    ELPHAPEX = ElphapexModels
    BRAIINS = BraiinsModels
--- a/pyasic/miners/antminer/bmminer/X21/S21.py
+++ b/pyasic/miners/antminer/bmminer/X21/S21.py
@@ -15,7 +15,7 @@
 # ------------------------------------------------------------------------------

 from pyasic.miners.backends import AntminerModern
-from pyasic.miners.device.models import S21, S21Pro
+from pyasic.miners.device.models import S21, S21Hydro, S21Pro


 class BMMinerS21(AntminerModern, S21):
@@ -24,3 +24,7 @@ class BMMinerS21(AntminerModern, S21):

 class BMMinerS21Pro(AntminerModern, S21Pro):
    pass
+
+
+class BMMinerS21Hydro(AntminerModern, S21Hydro):
+    pass
--- a/pyasic/miners/antminer/bmminer/X21/init.py
+++ b/pyasic/miners/antminer/bmminer/X21/init.py
@@ -13,5 +13,5 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .S21 import BMMinerS21, BMMinerS21Pro
+from .S21 import BMMinerS21, BMMinerS21Hydro, BMMinerS21Pro
 from .T21 import BMMinerT21
--- a/pyasic/miners/antminer/bosminer/X21/S21.py
+++ b/pyasic/miners/antminer/bosminer/X21/S21.py
@@ -15,8 +15,12 @@
 # ------------------------------------------------------------------------------

 from pyasic.miners.backends import BOSer
-from pyasic.miners.device.models import S21
+from pyasic.miners.device.models import S21, S21Pro


 class BOSMinerS21(BOSer, S21):
    pass
+
+
+class BOSMinerS21Pro(BOSer, S21Pro):
+    pass
--- a/pyasic/miners/antminer/bosminer/X21/init.py
+++ b/pyasic/miners/antminer/bosminer/X21/init.py
@@ -14,5 +14,5 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .S21 import BOSMinerS21
+from .S21 import BOSMinerS21, BOSMinerS21Pro
 from .T21 import BOSMinerT21
--- a/pyasic/miners/antminer/hiveon/X19/S19.py
+++ b/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

--- a/pyasic/miners/antminer/hiveon/X19/init.py
+++ b/pyasic/miners/antminer/hiveon/X19/init.py
@@ -25,6 +25,7 @@ from .S19 import (
    HiveonS19jPro,
    HiveonS19KPro,
    HiveonS19L,
+    HiveonS19NoPIC,
    HiveonS19Plus,
    HiveonS19Pro,
    HiveonS19ProHydro,
--- a/pyasic/miners/antminer/hiveon/X9/T9.py
+++ b/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
--- a/pyasic/miners/avalonminer/cgminer/nano/nano3.py
+++ b/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
--- a/pyasic/miners/backends/init.py
+++ b/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
--- a/pyasic/miners/backends/antminer.py
+++ b/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")],
--- a/pyasic/miners/backends/elphapex.py
+++ b/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
--- a/pyasic/miners/backends/vnish.py
+++ b/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()
--- a/pyasic/miners/device/makes.py
+++ b/pyasic/miners/device/makes.py
@@ -68,3 +68,7 @@ class VolcMinerMake(BaseMiner):

 class BraiinsMake(BaseMiner):
    make = MinerMake.BRAIINS
+
+
+class ElphapexMake(BaseMiner):
+    make = MinerMake.ELPHAPEX
--- a/pyasic/miners/device/models/init.py
+++ b/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 *
--- a/pyasic/miners/device/models/antminer/X21/S21.py
+++ b/pyasic/miners/device/models/antminer/X21/S21.py
@@ -34,3 +34,12 @@ class S21Pro(AntMinerMake):
    expected_fans = 4
    expected_hashboards = 3
    algo = MinerAlgo.SHA256
+
+
+class S21Hydro(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S21Hydro
+
+    expected_chips = 216
+    expected_hashboards = 2
+    expected_fans = 0
+    algo = MinerAlgo.SHA256
--- a/pyasic/miners/device/models/antminer/X21/init.py
+++ b/pyasic/miners/device/models/antminer/X21/init.py
@@ -14,5 +14,5 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .S21 import S21, S21Pro
+from .S21 import S21, S21Hydro, S21Pro
 from .T21 import T21
--- a/pyasic/miners/device/models/elphapex/DGX/DG1.py
+++ b/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
--- a/pyasic/miners/device/models/elphapex/DGX/init.py
+++ b/pyasic/miners/device/models/elphapex/DGX/init.py
@@ -0,0 +1 @@
+from .DG1 import DG1Plus
--- a/pyasic/miners/device/models/elphapex/init.py
+++ b/pyasic/miners/device/models/elphapex/init.py
@@ -0,0 +1 @@
+from .DGX import *
--- a/pyasic/miners/device/models/luckyminer/LV/LV07.py
+++ b/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
--- a/pyasic/miners/device/models/luckyminer/LV/LV08.py
+++ b/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
--- a/pyasic/miners/device/models/luckyminer/LV/init.py
+++ b/pyasic/miners/device/models/luckyminer/LV/init.py
@@ -1 +1,2 @@
+from .LV07 import LV07
 from .LV08 import LV08
--- a/pyasic/miners/elphapex/init.py
+++ b/pyasic/miners/elphapex/init.py
@@ -0,0 +1 @@
+from .daoge import *
--- a/pyasic/miners/elphapex/daoge/DGX/DG1.py
+++ b/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
--- a/pyasic/miners/elphapex/daoge/DGX/init.py
+++ b/pyasic/miners/elphapex/daoge/DGX/init.py
@@ -0,0 +1 @@
+from .DG1 import ElphapexDG1Plus
--- a/pyasic/miners/elphapex/daoge/init.py
+++ b/pyasic/miners/elphapex/daoge/init.py
@@ -0,0 +1 @@
+from .DGX import *
--- a/pyasic/miners/factory.py
+++ b/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 = {
@@ -119,6 +121,7 @@ MINER_CLASSES = {
        "ANTMINER BHB68606": BMMinerS21,  # ???
        "ANTMINER S21 PRO": BMMinerS21Pro,
        "ANTMINER T21": BMMinerT21,
+        "ANTMINER S21 HYD.": BMMinerS21Hydro,
    },
    MinerTypes.WHATSMINER: {
        None: type("WhatsminerUnknown", (BTMiner, WhatsMinerMake), {}),
@@ -546,6 +549,7 @@ MINER_CLASSES = {
        "ANTMINER S19 PRO+ HYD.": BOSMinerS19ProPlusHydro,
        "ANTMINER T19": BOSMinerT19,
        "ANTMINER S21": BOSMinerS21,
+        "ANTMINER S21 PRO": BOSMinerS21Pro,
        "ANTMINER T21": BOSMinerT21,
        "BRAIINS MINI MINER BMM 100": BraiinsBMM100,
        "BRAIINS MINI MINER BMM 101": BraiinsBMM101,
@@ -594,6 +598,7 @@ MINER_CLASSES = {
        "ANTMINER T9": HiveonT9,
        "ANTMINER S19JPRO": HiveonS19jPro,
        "ANTMINER S19": HiveonS19,
+        "ANTMINER S19X88": HiveonS19NoPIC,
    },
    MinerTypes.LUX_OS: {
        None: LUXMiner,
@@ -638,7 +643,8 @@ MINER_CLASSES = {
    },
    MinerTypes.LUCKYMINER: {
        None: LuckyMiner,
-        "BM1366": LuckyMinerLV08,
+        "LV08": LuckyMinerLV08,
+        "LV07": LuckyMinerLV07,
    },
    MinerTypes.ICERIVER: {
        None: type("IceRiverUnknown", (IceRiver, IceRiverMake), {}),
@@ -660,6 +666,10 @@ MINER_CLASSES = {
        None: type("VolcMinerUnknown", (BlackMiner, VolcMinerMake), {}),
        "VOLCMINER D1": VolcMinerD1,
    },
+    MinerTypes.ELPHAPEX: {
+        None: type("ElphapexUnknown", (ElphapexMiner, ElphapexMake), {}),
+        "DG1+1": ElphapexDG1Plus,
+    },
 }


@@ -741,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)

@@ -824,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 (
@@ -886,6 +901,7 @@ class MinerFactory:
            await writer.drain()

            # loop to receive all the data
+            timeouts_remaining = max(1, int(settings.get("factory_get_timeout", 3)))
            while True:
                try:
                    d = await asyncio.wait_for(reader.read(4096), timeout=1)
@@ -893,7 +909,10 @@ class MinerFactory:
                        break
                    data += d
                except asyncio.TimeoutError:
-                    pass
+                    timeouts_remaining -= 1
+                    if not timeouts_remaining:
+                        logger.warning(f"{ip}: Socket ping timeout.")
+                        break
                except ConnectionResetError:
                    return
        except asyncio.CancelledError:
@@ -1305,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

@@ -1376,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()

--- a/pyasic/miners/luckyminer/espminer/LV/LV07.py
+++ b/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
--- a/pyasic/miners/luckyminer/espminer/LV/init.py
+++ b/pyasic/miners/luckyminer/espminer/LV/init.py
@@ -1 +1,2 @@
+from .LV07 import LuckyMinerLV07
 from .LV08 import LuckyMinerLV08
--- a/pyasic/settings/init.py
+++ b/pyasic/settings/init.py
@@ -31,7 +31,7 @@ _settings = {  # defaults
    "default_whatsminer_rpc_password": "admin",
    "default_innosilicon_web_password": "admin",
    "default_antminer_web_password": "root",
-    "default_hammer_web_password": "ltc@dog",
+    "default_hammer_web_password": "root",
    "default_volcminer_web_password": "ltc@dog",
    "default_bosminer_web_password": "root",
    "default_vnish_web_password": "admin",
@@ -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",
 }
--- a/pyasic/web/avalonminer.py
+++ b/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")
--- a/pyasic/web/elphapex.py
+++ b/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")
--- a/pyasic/web/hiveon.py
+++ b/pyasic/web/hiveon.py
@@ -15,7 +15,6 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations

-import asyncio
 import json
 from pathlib import Path
 from typing import Any
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "pyasic"
-version = "0.70.2"
+version = "0.71.4"

 description = "A simplified and standardized interface for Bitcoin ASICs."
 authors = [{name = "UpstreamData", email = "brett@upstreamdata.ca"}]
@@ -44,6 +44,7 @@ requires-python = ">3.9, <4.0"
 dependencies = [
    "httpx>=0.26.0",
    "asyncssh>=2.17.0",
+    "cryptography>=39.0",
    "passlib>=1.7.4",
    "pyaml>=23.12.0",
    "tomli (>=2.2.1,<3.0.0) ; python_version < '3.11'",
--- a/tests/init.py
+++ b/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 *

--- a/tests/miners_tests/backends_tests/init.py
+++ b/tests/miners_tests/backends_tests/init.py
@@ -1 +1,2 @@
+from .alphapex_tests import *
 from .hammer_tests import *
--- a/tests/miners_tests/backends_tests/alphapex_tests/init.py
+++ b/tests/miners_tests/backends_tests/alphapex_tests/init.py
@@ -0,0 +1 @@
+from .version_1_0_2 import TestElphapexMiners
--- a/tests/miners_tests/backends_tests/alphapex_tests/version_1_0_2.py
+++ b/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)
Author	SHA1	Message	Date
Upstream Data	71c8905674	version: bump version number	2025-02-04 16:00:18 -07:00
Upstream Data	15c3806fbf	refactor: cleanup some imports	2025-02-04 15:59:32 -07:00
Upstream Data	a5c42c9c2b	feature: add support for Elphapex DG1+	2025-02-04 15:59:32 -07:00
Upstream Data	90d8a795e6	version: bump version number	2025-02-03 09:39:49 -07:00
Upstream Data	07cf1b134c	feature: add support for vnish error codes	2025-02-03 09:39:30 -07:00
Upstream Data	53e1f33fa6	version: bump version number	2025-02-03 09:32:44 -07:00
Upstream Data	16ab2bd4e3	feature: add support for luckyminer LV07	2025-02-03 09:32:16 -07:00
Upstream Data	de728f12d2	version: bump version number	2025-02-03 09:27:43 -07:00
Upstream Data	8092e12dfb	feature: add support for S19X88 Hiveon	2025-02-03 09:27:18 -07:00
b-rowan	e70c3e9f79	version: bump version number	2025-01-30 17:56:47 -07:00
b-rowan	39a97f2914	feature: add mac address support for avalon nano 3	2025-01-30 17:56:16 -07:00
b-rowan	35af74ad1a	version: bump version number	2025-01-30 07:14:50 -07:00
Erik Olof Gunnar Andersson	15fa91fb98	bug: don’t timeout forever on _socket_ping (#288 ) * Don't timeout forever on _socket_ping * Use factory_get_timeout to configure number of allowed retries * Add warning log	2025-01-30 07:05:29 -07:00
James Hilliard	084987a3e1	bug: Add cryptography direct dependency (#286 )	2025-01-29 10:01:10 -07:00
b-rowan	e93cc77a58	ci: update pre-commit hooks	2025-01-28 21:29:43 -07:00
b-rowan	788d43c51c	version: bump version number	2025-01-28 21:27:17 -07:00
Adrian	74c22b82ce	bug: add miner algo type for S21 Hydro (#285 )	2025-01-28 21:20:39 -07:00
Upstream Data	1f46ce1b9a	version: bump version number	2025-01-28 09:36:56 -07:00
Adrian	7964336a0c	feature: add support for S21 Hydro (#283 )	2025-01-28 09:36:15 -07:00
Upstream Data	a24fc07c2a	ci: update pre-commit to run docs generation when committing.	2025-01-28 08:51:13 -07:00
Upstream Data	4c64481d3b	bug: do not run unittest when running in precommit.ci	2025-01-28 08:33:02 -07:00
Upstream Data	66fb5834f0	version: bump version number	2025-01-23 13:37:28 -07:00
Upstream Data	db05cc1d97	feature: add support for S21 Pro BOS	2025-01-23 13:37:04 -07:00
Brett Rowan	418e3ce26e	Merge pull request #281 from UpstreamData/fix_hammer_pass	2025-01-23 07:42:20 -07:00
John-Paul Compagnone	5a0bb11a44	fix hammer default password	2025-01-23 08:35:37 -05:00
				`@@ -0,0 +1 @@`
				`from .version_1_0_2 import TestElphapexMiners`