docs: update docs

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

.pre-commit-config.yaml

@@ -5,7 +5,7 @@ ci:
     - generate-docs
 repos:
 -   repo: https://github.com/python-poetry/poetry
-    rev: 2.1.1
+    rev: 2.1.2
     hooks:
       - id: poetry-check
       - id: poetry-lock

docs/miners/antminer/X19.md

@@ -677,6 +677,19 @@
         show_root_heading: false
         heading_level: 0
 
+## S19k Pro Dual (ePIC)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.epic.X19.S19.ePICS19kProDual
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19 (Hive)
 
 - [ ] Shutdowns
@@ -746,7 +759,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19
@@ -759,7 +772,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19Pro
@@ -772,7 +785,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19XP
@@ -785,7 +798,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jPro
@@ -798,7 +811,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jProPlus
@@ -811,7 +824,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19kPro
@@ -824,7 +837,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X19.T19.LUXMinerT19

docs/miners/antminer/X21.md

@@ -40,6 +40,32 @@
         show_root_heading: false
         heading_level: 0
 
+## S21+ (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S21+ Hydro (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21PlusHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## T21 (Stock)
 
 - [x] Shutdowns
@@ -161,7 +187,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X21.S21.LUXMinerS21
@@ -170,6 +196,19 @@
         show_root_heading: false
         heading_level: 0
 
+## T21 (LuxOS)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.luxos.X21.T21.LUXMinerT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S21 (MaraFW)
 
 - [ ] Shutdowns

docs/miners/antminer/X9.md

@@ -122,7 +122,7 @@
 
 - [x] Shutdowns
 - [ ] Power Modes
-- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets
 
 ::: pyasic.miners.antminer.luxos.X9.S9.LUXMinerS9

docs/miners/avalonminer/nano.md

@@ -1,6 +1,19 @@
 # pyasic
 ## nano Models
 
+## Avalon Nano 3s (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.avalonminer.cgminer.nano.nano3.CGMinerAvalonNano3s
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## Avalon Nano 3 (Stock)
 
 - [ ] Shutdowns

docs/miners/blockminer/blockminer.md

@@ -27,3 +27,16 @@
         show_root_heading: false
         heading_level: 0
 
+## BlockMiner eLITE 1.0 (ePIC)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.blockminer.epic.blockminer.blockminer.ePICBlockMinerELITE1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+

docs/miners/supported_types.md

@@ -103,6 +103,8 @@ details {
                     <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
                     <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
                     <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
+                    <li><a href="../antminer/X21#s21_1-stock">S21+ (Stock)</a></li>
+                    <li><a href="../antminer/X21#s21_1-hydro-stock">S21+ Hydro (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>
@@ -552,6 +554,7 @@ details {
             <summary>nano Series:</summary>
                 <ul>
                     <li><a href="../avalonminer/nano#avalon-nano-3-stock">Avalon Nano 3 (Stock)</a></li>
+                    <li><a href="../avalonminer/nano#avalon-nano-3s-stock">Avalon Nano 3s (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -736,6 +739,7 @@ details {
                     <li><a href="../antminer/X19#s19k-pro-epic">S19k Pro (ePIC)</a></li>
                     <li><a href="../antminer/X19#s19-xp-epic">S19 XP (ePIC)</a></li>
                     <li><a href="../antminer/X19#s19j-pro-dual-epic">S19j Pro Dual (ePIC)</a></li>
+                    <li><a href="../antminer/X19#s19k-pro-dual-epic">S19k Pro Dual (ePIC)</a></li>
                 </ul>
         </details>
         <details>
@@ -751,6 +755,7 @@ details {
                 <ul>
                     <li><a href="../blockminer/blockminer#blockminer-520i-epic">BlockMiner 520i (ePIC)</a></li>
                     <li><a href="../blockminer/blockminer#blockminer-720i-epic">BlockMiner 720i (ePIC)</a></li>
+                    <li><a href="../blockminer/blockminer#blockminer-elite-1.0-epic">BlockMiner eLITE 1.0 (ePIC)</a></li>
                 </ul>
         </details>
     </ul>
@@ -811,6 +816,7 @@ details {
             <summary>X21 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X21#s21-luxos">S21 (LuxOS)</a></li>
+                    <li><a href="../antminer/X21#t21-luxos">T21 (LuxOS)</a></li>
                 </ul>
         </details>
     </ul>

pyasic/config/mining/__init__.py

@@ -82,6 +82,9 @@ class MiningModeNormal(MinerConfigValue):
     def as_luxos(self) -> dict:
         return {"autotunerset": {"enabled": False}}
 
+    def as_bosminer(self) -> dict:
+        return {"autotuning": {"enabled": True}}
+
 
 class MiningModeSleep(MinerConfigValue):
     mode: str = field(init=False, default="sleep")
@@ -255,18 +258,18 @@ class MiningModePowerTune(MinerConfigValue):
             sd_cfg = {}
             if self.scaling.shutdown is not None:
                 sd_cfg = self.scaling.shutdown.as_boser()
-            cfg["set_dps"] = (
-                SetDpsRequest(
-                    enable=True,
-                    **sd_cfg,
-                    target=DpsTarget(
-                        power_target=DpsPowerTarget(
-                            power_step=Power(self.scaling.step),
-                            min_power_target=Power(self.scaling.minimum),
-                        )
-                    ),
-                ),
+            power_target_kwargs = {}
+            if self.scaling.step is not None:
+                power_target_kwargs["power_step"] = Power(self.scaling.step)
+            if self.scaling.minimum is not None:
+                power_target_kwargs["min_power_target"] = Power(self.scaling.minimum)
+            cfg["set_dps"] = SetDpsRequest(
+                save_action=SaveAction.SAVE_AND_APPLY,
+                enable=True,
+                **sd_cfg,
+                target=DpsTarget(power_target=DpsPowerTarget(**power_target_kwargs)),
             )
+
         return cfg
 
     def as_auradine(self) -> dict:
@@ -327,7 +330,6 @@ class MiningModeHashrateTune(MinerConfigValue):
             conf["hashrate_target"] = self.hashrate
         return {"autotuning": conf}
 
-    @property
     def as_boser(self) -> dict:
         cfg = {
             "set_performance_mode": SetPerformanceModeRequest(
@@ -347,18 +349,24 @@ class MiningModeHashrateTune(MinerConfigValue):
             sd_cfg = {}
             if self.scaling.shutdown is not None:
                 sd_cfg = self.scaling.shutdown.as_boser()
-            cfg["set_dps"] = (
-                SetDpsRequest(
-                    enable=True,
-                    **sd_cfg,
-                    target=DpsTarget(
-                        hashrate_target=DpsHashrateTarget(
-                            hashrate_step=TeraHashrate(self.scaling.step),
-                            min_hashrate_target=TeraHashrate(self.scaling.minimum),
-                        )
-                    ),
+            hashrate_target_kwargs = {}
+            if self.scaling.step is not None:
+                hashrate_target_kwargs["hashrate_step"] = TeraHashrate(
+                    self.scaling.step
+                )
+            if self.scaling.minimum is not None:
+                hashrate_target_kwargs["min_hashrate_target"] = TeraHashrate(
+                    self.scaling.minimum
+                )
+            cfg["set_dps"] = SetDpsRequest(
+                save_action=SaveAction.SAVE_AND_APPLY,
+                enable=True,
+                **sd_cfg,
+                target=DpsTarget(
+                    hashrate_target=DpsHashrateTarget(**hashrate_target_kwargs)
                 ),
             )
+
         return cfg
 
     def as_auradine(self) -> dict:
@@ -692,6 +700,7 @@ class MiningModeConfig(MinerConfigOption):
                 return cls.hashrate_tuning(
                     scaling=ScalingConfig.from_bosminer(toml_conf, mode="hashrate"),
                 )
+        return cls.default()
 
     @classmethod
     def from_vnish(cls, web_settings: dict, web_presets: list[dict]):

pyasic/config/pools.py

@@ -190,7 +190,7 @@ class Pool(MinerConfigValue):
         return cls(
             url=toml_pool_conf["url"],
             user=toml_pool_conf["user"],
-            password=toml_pool_conf["password"],
+            password=toml_pool_conf.get("password", ""),
         )
 
     @classmethod

pyasic/data/__init__.py

@@ -284,10 +284,22 @@ class MinerData(BaseModel):
     @computed_field  # type: ignore[misc]
     @property
     def efficiency(self) -> int | None:
+        efficiency = self._efficiency(0)
+        if efficiency is None:
+            return None
+        else:
+            return int(efficiency)
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def efficiency_fract(self) -> float | None:
+        self._efficiency(2)
+
+    def _efficiency(self, ndigits: int) -> float | None:
         if self.hashrate is None or self.wattage is None:
             return None
         try:
-            return round(self.wattage / float(self.hashrate))
+            return round(self.wattage / float(self.hashrate), ndigits)
         except ZeroDivisionError:
             return 0
 

pyasic/data/boards.py

@@ -28,6 +28,8 @@ class HashBoard(BaseModel):
     Attributes:
         slot: The slot of the board as an int.
         hashrate: The hashrate of the board in TH/s as a float.
+        inlet_temp: Inlet temperature for hydro asics as an int
+        outlet_temp: Outlet temperature for hydro asics as an int
         temp: The temperature of the PCB as an int.
         chip_temp: The temperature of the chips as an int.
         chips: The chip count of the board as an int.
@@ -41,6 +43,8 @@ class HashBoard(BaseModel):
 
     slot: int = 0
     hashrate: AlgoHashRateType | None = None
+    inlet_temp: float | None = None
+    outlet_temp: float | None = None
     temp: float | None = None
     chip_temp: float | None = None
     chips: int | None = None

pyasic/device/models.py

@@ -58,6 +58,8 @@ class AntminerModels(MinerModelType):
     S19jXP = "S19j XP"
     T19 = "T19"
     S21 = "S21"
+    S21Plus = "S21+"
+    S21PlusHydro = "S21+ Hydro"
     S21Pro = "S21 Pro"
     S21Hydro = "S21 Hydro"
     T21 = "T21"
@@ -450,6 +452,7 @@ class AvalonminerModels(MinerModelType):
     Avalon1246 = "Avalon 1246"
     Avalon1566 = "Avalon 1566"
     AvalonNano3 = "Avalon Nano 3"
+    AvalonNano3s = "Avalon Nano 3s"
 
     def __str__(self):
         return self.value
@@ -480,7 +483,9 @@ class GoldshellModels(MinerModelType):
 class ePICModels(MinerModelType):
     BM520i = "BlockMiner 520i"
     BM720i = "BlockMiner 720i"
+    eLITE1 = "BlockMiner eLITE 1.0"
     S19jProDual = "S19j Pro Dual"
+    S19kProDual = "S19k Pro Dual"
 
     def __str__(self):
         return self.value

pyasic/miners/antminer/bmminer/X21/S21.py

@@ -15,13 +15,21 @@
 # ------------------------------------------------------------------------------
 
 from pyasic.miners.backends import AntminerModern
-from pyasic.miners.device.models import S21, S21Hydro, S21Pro
+from pyasic.miners.device.models import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro
 
 
 class BMMinerS21(AntminerModern, S21):
     pass
 
 
+class BMMinerS21Plus(AntminerModern, S21Plus):
+    pass
+
+
+class BMMinerS21PlusHydro(AntminerModern, S21PlusHydro):
+    pass
+
+
 class BMMinerS21Pro(AntminerModern, S21Pro):
     pass
 

pyasic/miners/antminer/bmminer/X21/__init__.py

@@ -13,5 +13,11 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .S21 import BMMinerS21, BMMinerS21Hydro, BMMinerS21Pro
+from .S21 import (
+    BMMinerS21,
+    BMMinerS21Hydro,
+    BMMinerS21Plus,
+    BMMinerS21PlusHydro,
+    BMMinerS21Pro,
+)
 from .T21 import BMMinerT21

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

@@ -59,3 +59,9 @@ class ePICS19jProDual(ePIC, S19jPro):
     raw_model = MinerModel.EPIC.S19jProDual
     expected_fans = S19jPro.expected_fans * 2
     expected_hashboards = S19jPro.expected_hashboards * 2
+
+
+class ePICS19kProDual(ePIC, S19kPro):
+    raw_model = MinerModel.EPIC.S19kProDual
+    expected_fans = S19kPro.expected_fans * 2
+    expected_hashboards = S19kPro.expected_hashboards * 2

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

@@ -21,6 +21,7 @@ from .S19 import (
     ePICS19jProDual,
     ePICS19jProPlus,
     ePICS19kPro,
+    ePICS19kProDual,
     ePICS19Pro,
     ePICS19XP,
 )

pyasic/miners/antminer/luxos/X21/T21.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  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.miners.backends import LUXMiner
+from pyasic.miners.device.models import S21, T21
+
+
+class LUXMinerT21(LUXMiner, T21):
+    pass

pyasic/miners/antminer/luxos/X21/__init__.py

@@ -15,3 +15,4 @@
 # ------------------------------------------------------------------------------
 
 from .S21 import LUXMinerS21
+from .T21 import LUXMinerT21

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

@@ -14,4 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from .nano3 import CGMinerAvalonNano3
+from .nano3 import CGMinerAvalonNano3, CGMinerAvalonNano3s

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

@@ -13,9 +13,11 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from typing import Optional
+from typing import List, Optional
 
 from pyasic import APIError
+from pyasic.data.boards import HashBoard
+from pyasic.device.algorithm.hashrate import AlgoHashRate
 from pyasic.miners.backends import AvalonMiner
 from pyasic.miners.data import (
     DataFunction,
@@ -24,7 +26,7 @@ from pyasic.miners.data import (
     RPCAPICommand,
     WebAPICommand,
 )
-from pyasic.miners.device.models import AvalonNano3
+from pyasic.miners.device.models import AvalonNano3, AvalonNano3s
 from pyasic.web.avalonminer import AvalonMinerWebAPI
 
 AVALON_NANO_DATA_LOC = DataLocations(
@@ -84,6 +86,63 @@ AVALON_NANO_DATA_LOC = DataLocations(
     }
 )
 
+AVALON_NANO3S_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        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_stats", "stats")],
+        ),
+        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.WATTAGE): DataFunction(
+            "_get_wattage",
+            [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):
     _web_cls = AvalonMinerWebAPI
@@ -105,3 +164,68 @@ class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
                     return mac.upper()
             except (KeyError, ValueError):
                 pass
+
+
+class CGMinerAvalonNano3s(AvalonMiner, AvalonNano3s):
+
+    data_locations = AVALON_NANO3S_DATA_LOC
+
+    async def _get_wattage(self, rpc_stats: dict = None) -> Optional[int]:
+        if rpc_stats is None:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats is not None:
+            try:
+                unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
+                parsed_stats = self.parse_stats(unparsed_stats)
+                return int(parsed_stats["PS"][6])
+            except (IndexError, KeyError, ValueError, TypeError):
+                pass
+
+    async def _get_hashrate(self, rpc_stats: dict = None) -> Optional[AlgoHashRate]:
+        if rpc_stats is None:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats is not None:
+            try:
+                unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
+                parsed_stats = self.parse_stats(unparsed_stats)
+                return self.algo.hashrate(
+                    rate=float(parsed_stats["GHSspd"][0]), unit=self.algo.unit.GH
+                ).into(self.algo.unit.default)
+            except (IndexError, KeyError, ValueError, TypeError):
+                pass
+
+    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        hashboards = await AvalonMiner._get_hashboards(self, rpc_stats)
+
+        if rpc_stats is None:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats is not None:
+
+            try:
+                unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
+                parsed_stats = self.parse_stats(unparsed_stats)
+            except (IndexError, KeyError, ValueError, TypeError):
+                return hashboards
+
+            for board in range(len(hashboards)):
+                try:
+                    board_hr = parsed_stats["GHSspd"][board]
+                    hashboards[board].hashrate = self.algo.hashrate(
+                        rate=float(board_hr), unit=self.algo.unit.GH
+                    ).into(self.algo.unit.default)
+                except LookupError:
+                    pass
+
+        return hashboards

pyasic/miners/backends/antminer.py

@@ -252,6 +252,9 @@ class AntminerModern(BMMiner):
         return errors
 
     async def _get_hashboards(self) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=idx, expected_chips=self.expected_chips)
             for idx in range(self.expected_hashboards)
@@ -269,18 +272,47 @@ class AntminerModern(BMMiner):
                         rate=board["rate_real"], unit=self.algo.unit.GH
                     ).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 == 0, board["temp_chip"])
-                    )
-                    hashboards[board["index"]].chip_temp = sum(chip_temp_data) / len(
-                        chip_temp_data
-                    )
+
+                    if "S21+ Hyd" in self.model:
+                        hashboards[board["index"]].inlet_temp = board["temp_pcb"][0]
+                        hashboards[board["index"]].outlet_temp = board["temp_pcb"][2]
+                        hashboards[board["index"]].chip_temp = board["temp_pic"][0]
+                        board_temp_data = list(
+                            filter(
+                                lambda x: not x == 0,
+                                [
+                                    board["temp_pic"][1],
+                                    board["temp_pic"][2],
+                                    board["temp_pic"][3],
+                                    board["temp_pcb"][1],
+                                    board["temp_pcb"][3],
+                                ],
+                            )
+                        )
+                        hashboards[board["index"]].temp = (
+                            sum(board_temp_data) / len(board_temp_data)
+                            if len(board_temp_data) > 0
+                            else 0
+                        )
+
+                    else:
+                        board_temp_data = list(
+                            filter(lambda x: not x == 0, board["temp_pcb"])
+                        )
+                        hashboards[board["index"]].temp = (
+                            sum(board_temp_data) / len(board_temp_data)
+                            if len(board_temp_data) > 0
+                            else 0
+                        )
+                        chip_temp_data = list(
+                            filter(lambda x: not x == 0, board["temp_chip"])
+                        )
+                        hashboards[board["index"]].chip_temp = (
+                            sum(chip_temp_data) / len(chip_temp_data)
+                            if len(chip_temp_data) > 0
+                            else 0
+                        )
+
                     hashboards[board["index"]].serial_number = board["sn"]
                     hashboards[board["index"]].missing = False
             except LookupError:
@@ -565,6 +597,9 @@ class AntminerOld(CGMiner):
                 pass
 
     async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_stats is None:
             try:
                 rpc_stats = await self.rpc.stats()
@@ -593,6 +628,8 @@ class AntminerOld(CGMiner):
         return fans_data
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
         hashboards = []
 
         if rpc_stats is None:

pyasic/miners/backends/auradine.py

@@ -303,6 +303,9 @@ class Auradine(StockFirmware):
     async def _get_hashboards(
         self, rpc_devs: dict = None, web_ipreport: dict = None
     ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=i, expected_chips=self.expected_chips)
             for i in range(self.expected_hashboards)
@@ -382,6 +385,9 @@ class Auradine(StockFirmware):
                 pass
 
     async def _get_fans(self, web_fan: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_fan is None:
             try:
                 web_fan = await self.web.get_fan()

pyasic/miners/backends/avalonminer.py

@@ -212,6 +212,9 @@ class AvalonMiner(CGMiner):
                 pass
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=i, expected_chips=self.expected_chips)
             for i in range(self.expected_hashboards)
@@ -326,6 +329,9 @@ class AvalonMiner(CGMiner):
                 pass
 
     async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_stats is None:
             try:
                 rpc_stats = await self.rpc.stats()

pyasic/miners/backends/bfgminer.py

@@ -129,6 +129,9 @@ class BFGMiner(StockFirmware):
                 pass
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = []
 
         if rpc_stats is None:
@@ -185,6 +188,9 @@ class BFGMiner(StockFirmware):
         return hashboards
 
     async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_stats is None:
             try:
                 rpc_stats = await self.rpc.stats()

pyasic/miners/backends/bmminer.py

@@ -133,6 +133,9 @@ class BMMiner(StockFirmware):
                 pass
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = []
 
         if rpc_stats is None:
@@ -202,6 +205,9 @@ class BMMiner(StockFirmware):
         return hashboards
 
     async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_stats is None:
             try:
                 rpc_stats = await self.rpc.stats()

pyasic/miners/backends/braiins_os.py

@@ -376,6 +376,9 @@ class BOSMiner(BraiinsOSFirmware):
         rpc_devdetails: dict = None,
         rpc_devs: dict = None,
     ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=i, expected_chips=self.expected_chips)
             for i in range(self.expected_hashboards)
@@ -473,6 +476,9 @@ class BOSMiner(BraiinsOSFirmware):
                 pass
 
     async def _get_fans(self, rpc_fans: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_fans is None:
             try:
                 rpc_fans = await self.rpc.fans()
@@ -926,6 +932,9 @@ class BOSer(BraiinsOSFirmware):
                 pass
 
     async def _get_hashboards(self, grpc_hashboards: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=i, expected_chips=self.expected_chips)
             for i in range(self.expected_hashboards)
@@ -997,6 +1006,9 @@ class BOSer(BraiinsOSFirmware):
                 pass
 
     async def _get_fans(self, grpc_cooling_state: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if grpc_cooling_state is None:
             try:
                 grpc_cooling_state = await self.web.get_cooling_state()

pyasic/miners/backends/btminer.py

@@ -412,6 +412,9 @@ class BTMiner(StockFirmware):
                 pass
 
     async def _get_hashboards(self, rpc_devs: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=i, expected_chips=self.expected_chips)
             for i in range(self.expected_hashboards)
@@ -490,6 +493,9 @@ class BTMiner(StockFirmware):
     async def _get_fans(
         self, rpc_summary: dict = None, rpc_get_psu: dict = None
     ) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_summary is None:
             try:
                 rpc_summary = await self.rpc.summary()

pyasic/miners/backends/elphapex.py

@@ -209,6 +209,9 @@ class ElphapexMiner(StockFirmware):
         return errors
 
     async def _get_hashboards(self, web_stats: dict | None = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=idx, expected_chips=self.expected_chips)
             for idx in range(self.expected_hashboards)
@@ -317,6 +320,9 @@ class ElphapexMiner(StockFirmware):
                 pass
 
     async def _get_fans(self, web_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_stats is None:
             try:
                 web_stats = await self.web.stats()

pyasic/miners/backends/epic.py

@@ -21,7 +21,7 @@ from pyasic.config import MinerConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import MinerErrorData, X19Error
 from pyasic.data.pools import PoolMetrics, PoolUrl
-from pyasic.device.algorithm import AlgoHashRate
+from pyasic.device.algorithm import AlgoHashRate, ScryptAlgo
 from pyasic.errors import APIError
 from pyasic.logger import logger
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
@@ -138,6 +138,8 @@ class ePIC(ePICFirmware):
                 await self.web.set_ptune_algo(conf["ptune"])
 
             ## Pools
+            if self.algo == ScryptAlgo:
+                conf["pools"]["coin"] = "Ltc"
             await self.web.set_pools(conf["pools"])
         except APIError:
             pass
@@ -283,6 +285,9 @@ class ePIC(ePICFirmware):
                 pass
 
     async def _get_fans(self, web_summary: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_summary is None:
             try:
                 web_summary = await self.web.summary()
@@ -302,6 +307,9 @@ class ePIC(ePICFirmware):
     async def _get_hashboards(
         self, web_summary: dict = None, web_capabilities: dict = None
     ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         if web_summary is None:
             try:
                 web_summary = await self.web.summary()

pyasic/miners/backends/espminer.py

@@ -141,6 +141,9 @@ class ESPMiner(BaseMiner):
                 pass
 
     async def _get_hashboards(self, web_system_info: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         if web_system_info is None:
             try:
                 web_system_info = await self.web.system_info()
@@ -169,6 +172,9 @@ class ESPMiner(BaseMiner):
         return []
 
     async def _get_fans(self, web_system_info: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_system_info is None:
             try:
                 web_system_info = await self.web.system_info()

pyasic/miners/backends/goldshell.py

@@ -145,6 +145,9 @@ class GoldshellMiner(BFGMiner):
     async def _get_hashboards(
         self, rpc_devs: dict = None, rpc_devdetails: dict = None
     ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         if rpc_devs is None:
             try:
                 rpc_devs = await self.rpc.devs()

pyasic/miners/backends/hammer.py

@@ -180,6 +180,9 @@ class BlackMiner(StockFirmware):
                 pass
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = []
 
         if rpc_stats is None:
@@ -245,6 +248,9 @@ class BlackMiner(StockFirmware):
         return hashboards
 
     async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_stats is None:
             try:
                 rpc_stats = await self.rpc.stats()

pyasic/miners/backends/iceriver.py

@@ -79,6 +79,9 @@ class IceRiver(StockFirmware):
         return MinerConfig.from_iceriver(web_userpanel)
 
     async def _get_fans(self, web_userpanel: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_userpanel is None:
             try:
                 web_userpanel = await self.web.userpanel()
@@ -170,6 +173,9 @@ class IceRiver(StockFirmware):
                 pass
 
     async def _get_hashboards(self, web_userpanel: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         if web_userpanel is None:
             try:
                 web_userpanel = await self.web.userpanel()

pyasic/miners/backends/innosilicon.py

@@ -211,6 +211,9 @@ class Innosilicon(CGMiner):
     async def _get_hashboards(
         self, rpc_stats: dict = None, web_get_all: dict = None
     ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         if web_get_all:
             web_get_all = web_get_all["all"]
 
@@ -304,6 +307,9 @@ class Innosilicon(CGMiner):
                         return wattage
 
     async def _get_fans(self, web_get_all: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_get_all:
             web_get_all = web_get_all["all"]
 

pyasic/miners/backends/luxminer.py

@@ -86,6 +86,7 @@ class LUXMiner(LuxOSFirmware):
 
     supports_shutdown = True
     supports_presets = True
+    supports_autotuning = True
 
     data_locations = LUXMINER_DATA_LOC
 
@@ -191,10 +192,10 @@ class LUXMiner(LuxOSFirmware):
         try:
             if await self.atm_enabled():
                 re_enable_atm = True
-                await self.rpc.atmset("enabled=false")
+                await self.rpc.atmset(enabled=False)
             result = await self.rpc.profileset(new_preset)
             if re_enable_atm:
-                await self.rpc.atmset("enabled=true")
+                await self.rpc.atmset(enabled=True)
         except APIError:
             raise
         except Exception as e:
@@ -240,6 +241,9 @@ class LUXMiner(LuxOSFirmware):
                 pass
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=idx, expected_chips=self.expected_chips)
             for idx in range(self.expected_hashboards)
@@ -309,6 +313,9 @@ class LUXMiner(LuxOSFirmware):
             pass
 
     async def _get_fans(self, rpc_fans: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if rpc_fans is None:
             try:
                 rpc_fans = await self.rpc.fans()

pyasic/miners/backends/marathon.py

@@ -164,6 +164,9 @@ class MaraMiner(MaraFirmware):
                 pass
 
     async def _get_hashboards(self, web_hashboards: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
         hashboards = [
             HashBoard(slot=i, expected_chips=self.expected_chips)
             for i in range(self.expected_hashboards)
@@ -250,6 +253,9 @@ class MaraMiner(MaraFirmware):
                 pass
 
     async def _get_fans(self, web_fans: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
         if web_fans is None:
             try:
                 web_fans = await self.web.fans()

pyasic/miners/backends/unknown.py

@@ -97,7 +97,7 @@ class UnknownMiner(BaseMiner):
         return None
 
     async def _get_fans(self) -> List[Fan]:
-        return [Fan(), Fan(), Fan(), Fan()]
+        return []
 
     async def _get_fan_psu(self) -> Optional[int]:
         return None

pyasic/miners/blockminer/epic/blockminer/__init__.py

@@ -14,4 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from .blockminer import ePICBlockMiner520i, ePICBlockMiner720i
+from .blockminer import *

pyasic/miners/blockminer/epic/blockminer/blockminer.py

@@ -15,7 +15,11 @@
 # ------------------------------------------------------------------------------
 
 from pyasic.miners.backends import ePIC
-from pyasic.miners.device.models import BlockMiner520i, BlockMiner720i
+from pyasic.miners.device.models import (
+    BlockMiner520i,
+    BlockMiner720i,
+    BlockMinerELITE1,
+)
 
 
 class ePICBlockMiner520i(ePIC, BlockMiner520i):
@@ -24,3 +28,7 @@ class ePICBlockMiner520i(ePIC, BlockMiner520i):
 
 class ePICBlockMiner720i(ePIC, BlockMiner720i):
     pass
+
+
+class ePICBlockMinerELITE1(ePIC, BlockMinerELITE1):
+    pass

pyasic/miners/device/models/antminer/X21/S21.py

@@ -27,6 +27,24 @@ class S21(AntMinerMake):
     algo = MinerAlgo.SHA256
 
 
+class S21Plus(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S21Plus
+
+    expected_chips = 55
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
+
+
+class S21PlusHydro(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S21PlusHydro
+
+    expected_chips = 95
+    expected_fans = 0
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
+
+
 class S21Pro(AntMinerMake):
     raw_model = MinerModel.ANTMINER.S21Pro
 

pyasic/miners/device/models/antminer/X21/__init__.py

@@ -14,5 +14,5 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from .S21 import S21, S21Hydro, S21Pro
+from .S21 import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro
 from .T21 import T21

pyasic/miners/device/models/avalonminer/nano/__init__.py

@@ -1 +1 @@
-from .nano3 import AvalonNano3
+from .nano3 import AvalonNano3, AvalonNano3s

pyasic/miners/device/models/avalonminer/nano/nano3.py

@@ -10,3 +10,12 @@ class AvalonNano3(AvalonMinerMake):
     expected_chips = 10
     expected_fans = 1
     algo = MinerAlgo.SHA256
+
+
+class AvalonNano3s(AvalonMinerMake):
+    raw_model = MinerModel.AVALONMINER.AvalonNano3s
+
+    expected_hashboards = 1
+    expected_chips = 12
+    expected_fans = 1
+    algo = MinerAlgo.SHA256

pyasic/miners/device/models/epic/blockminer/blockminer.py

@@ -19,3 +19,12 @@ class BlockMiner720i(ePICMake):
     expected_fans = 4
     expected_hashboards = 3
     algo = MinerAlgo.SHA256
+
+
+class BlockMinerELITE1(ePICMake):
+    raw_model = MinerModel.EPIC.eLITE1
+
+    expected_chips = 105
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SCRYPT

pyasic/miners/factory.py

@@ -120,6 +120,8 @@ MINER_CLASSES = {
         "ANTMINER S21": BMMinerS21,
         "ANTMINER BHB68601": BMMinerS21,  # ???
         "ANTMINER BHB68606": BMMinerS21,  # ???
+        "ANTMINER S21+": BMMinerS21Plus,
+        "ANTMINER S21+ HYD.": BMMinerS21PlusHydro,
         "ANTMINER S21 PRO": BMMinerS21Pro,
         "ANTMINER T21": BMMinerT21,
         "ANTMINER S21 HYD.": BMMinerS21Hydro,
@@ -505,6 +507,7 @@ MINER_CLASSES = {
         "AVALONMINER 1166PRO": CGMinerAvalon1166Pro,
         "AVALONMINER 1246": CGMinerAvalon1246,
         "AVALONMINER NANO3": CGMinerAvalonNano3,
+        "AVALON NANO3S": CGMinerAvalonNano3s,
         "AVALONMINER 15-194": CGMinerAvalon1566,
     },
     MinerTypes.INNOSILICON: {
@@ -592,8 +595,10 @@ MINER_CLASSES = {
         "ANTMINER S21 PRO": ePICS21Pro,
         "ANTMINER T21": ePICT21,
         "ANTMINER S19J PRO DUAL": ePICS19jProDual,
+        "ANTMINER S19K PRO DUAL": ePICS19kProDual,
         "BLOCKMINER 520I": ePICBlockMiner520i,
         "BLOCKMINER 720I": ePICBlockMiner720i,
+        "BLOCKMINER ELITE 1.0": ePICBlockMinerELITE1,
     },
     MinerTypes.HIVEON: {
         None: HiveonModern,
@@ -618,6 +623,7 @@ MINER_CLASSES = {
         "ANTMINER S19 XP": LUXMinerS19XP,
         "ANTMINER T19": LUXMinerT19,
         "ANTMINER S21": LUXMinerS21,
+        "ANTMINER T21": LUXMinerT21,
     },
     MinerTypes.AURADINE: {
         None: type("AuradineUnknown", (Auradine, AuradineMake), {}),
@@ -876,8 +882,6 @@ class MinerFactory:
             return MinerTypes.INNOSILICON
         if "Miner UI" in web_text:
             return MinerTypes.AURADINE
-        if "<title>Antminer</title>" in web_text:
-            return MinerTypes.MSKMINER
 
     async def _get_miner_socket(self, ip: str) -> MinerTypes | None:
         commands = ["version", "devdetails"]

pyproject.toml

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