version: bump version number

.github/workflows/python-publish.yml

@@ -13,10 +13,10 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4.2.2
       - name: Publish GH release
-        uses: softprops/action-gh-release@v0.1.14
+        uses: softprops/action-gh-release@v2.1.0
       - name: Build using poetry and publish to PyPi
-        uses: JRubics/poetry-publish@v1.11
+        uses: JRubics/poetry-publish@v2.0
         with:
           pypi_token: ${{ secrets.PYPI_API_KEY }}

docs/miners/antminer/X19.md

@@ -302,6 +302,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S19k Pro (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19kPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## T19 (VNish)
 ::: pyasic.miners.antminer.vnish.X19.T19.VNishT19
     handler: python
@@ -358,13 +365,20 @@
         show_root_heading: false
         heading_level: 4
 
-## S19j Pro (Stock)
+## S19j Pro (Hive)
 ::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
+## S19 (Hive)
+::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## S19 (LuxOS)
 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19
     handler: python

docs/miners/antminer/X9.md

@@ -43,6 +43,13 @@
         show_root_heading: false
         heading_level: 4
 
+## L9 (Stock)
+::: pyasic.miners.antminer.bmminer.X9.L9.BMMinerL9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## S9 (BOS+)
 ::: pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9
     handler: python
@@ -50,7 +57,7 @@
         show_root_heading: false
         heading_level: 4
 
-## T9 (Stock)
+## T9 (Hive)
 ::: pyasic.miners.antminer.hiveon.X9.T9.HiveonT9
     handler: python
     options:

docs/miners/avalonminer/A11X.md

@@ -1,6 +1,13 @@
 # pyasic
 ## A11X Models
 
+## Avalon 1126 Pro (Stock)
+::: pyasic.miners.avalonminer.cgminer.A11X.A1126.CGMinerAvalon1126Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## Avalon 1166 Pro (Stock)
 ::: pyasic.miners.avalonminer.cgminer.A11X.A1166.CGMinerAvalon1166Pro
     handler: python

docs/miners/supported_types.md

@@ -49,6 +49,7 @@ details {
                     <li><a href="../antminer/X9#s9i-stock">S9i (Stock)</a></li>
                     <li><a href="../antminer/X9#s9j-stock">S9j (Stock)</a></li>
                     <li><a href="../antminer/X9#t9-stock">T9 (Stock)</a></li>
+                    <li><a href="../antminer/X9#l9-stock">L9 (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -377,6 +378,7 @@ details {
         <details>
             <summary>A11X Series:</summary>
                 <ul>
+                    <li><a href="../avalonminer/A11X#avalon-1126-pro-stock">Avalon 1126 Pro (Stock)</a></li>
                     <li><a href="../avalonminer/A11X#avalon-1166-pro-stock">Avalon 1166 Pro (Stock)</a></li>
                 </ul>
         </details>
@@ -531,6 +533,7 @@ details {
                     <li><a href="../antminer/X19#s19a-vnish">S19a (VNish)</a></li>
                     <li><a href="../antminer/X19#s19a-pro-vnish">S19a Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#s19-pro-hydro-vnish">S19 Pro Hydro (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19k-pro-vnish">S19k Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#t19-vnish">T19 (VNish)</a></li>
                 </ul>
         </details>
@@ -580,13 +583,14 @@ details {
         <details>
             <summary>X9 Series:</summary>
                 <ul>
-                    <li><a href="../antminer/X9#t9-stock">T9 (Stock)</a></li>
+                    <li><a href="../antminer/X9#t9-hive">T9 (Hive)</a></li>
                 </ul>
         </details>
         <details>
             <summary>X19 Series:</summary>
                 <ul>
-                    <li><a href="../antminer/X19#s19j-pro-stock">S19j Pro (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-hive">S19j Pro (Hive)</a></li>
+                    <li><a href="../antminer/X19#s19-hive">S19 (Hive)</a></li>
                 </ul>
         </details>
     </ul>

pyasic/config/__init__.py

@@ -245,13 +245,13 @@ class MinerConfig(BaseModel):
         )
 
     @classmethod
-    def from_vnish(cls, web_settings: dict) -> "MinerConfig":
+    def from_vnish(cls, web_settings: dict, web_presets: list[dict]) -> "MinerConfig":
         """Constructs a MinerConfig object from web settings for VNish miners."""
         return cls(
             pools=PoolConfig.from_vnish(web_settings),
             fan_mode=FanModeConfig.from_vnish(web_settings),
             temperature=TemperatureConfig.from_vnish(web_settings),
-            mining_mode=MiningModeConfig.from_vnish(web_settings),
+            mining_mode=MiningModeConfig.from_vnish(web_settings, web_presets),
         )
 
     @classmethod
@@ -299,3 +299,7 @@ class MinerConfig(BaseModel):
     @classmethod
     def from_hammer(cls, *args, **kwargs) -> "MinerConfig":
         return cls.from_am_modern(*args, **kwargs)
+
+    @classmethod
+    def from_hiveon_modern(cls, web_conf: dict) -> "MinerConfig":
+        return cls.from_am_modern(web_conf)

pyasic/config/mining/__init__.py

@@ -36,6 +36,7 @@ from pyasic.web.braiins_os.proto.braiins.bos.v1 import (
 )
 
 from .algo import TunerAlgo, TunerAlgoType
+from .presets import MiningPreset
 from .scaling import ScalingConfig
 
 
@@ -251,9 +252,9 @@ class MiningModeHashrateTune(MinerConfigValue):
         arbitrary_types_allowed = True
 
     mode: str = field(init=False, default="hashrate_tuning")
-    hashrate: int = None
+    hashrate: int | None = None
     algo: TunerAlgoType = field(default_factory=TunerAlgo.default)
-    scaling: ScalingConfig = None
+    scaling: ScalingConfig | None = None
 
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "MiningModeHashrateTune":
@@ -344,6 +345,29 @@ class MiningModeHashrateTune(MinerConfigValue):
         return {"autotunerset": {"enabled": True}}
 
 
+class MiningModePreset(MinerConfigValue):
+    mode: str = field(init=False, default="preset")
+
+    active_preset: MiningPreset
+    available_presets: list[MiningPreset] = field(default_factory=list)
+
+    def as_vnish(self) -> dict:
+        return {"overclock": {**self.active_preset.as_vnish()}}
+
+    @classmethod
+    def from_vnish(
+        cls, web_overclock_settings: dict, web_presets: list[dict]
+    ) -> "MiningModePreset":
+        active_preset = None
+        for preset in web_presets:
+            if preset["name"] == web_overclock_settings["preset"]:
+                active_preset = preset
+        return cls(
+            active_preset=MiningPreset.from_vnish(active_preset),
+            available_presets=[MiningPreset.from_vnish(p) for p in web_presets],
+        )
+
+
 class ManualBoardSettings(MinerConfigValue):
     freq: float
     volt: float
@@ -444,6 +468,7 @@ class MiningModeConfig(MinerConfigOption):
     sleep = MiningModeSleep
     power_tuning = MiningModePowerTune
     hashrate_tuning = MiningModeHashrateTune
+    preset = MiningModePreset
     manual = MiningModeManual
 
     @classmethod
@@ -561,7 +586,7 @@ class MiningModeConfig(MinerConfigOption):
                 )
 
     @classmethod
-    def from_vnish(cls, web_settings: dict):
+    def from_vnish(cls, web_settings: dict, web_presets: list[dict]):
         try:
             mode_settings = web_settings["miner"]["overclock"]
         except KeyError:
@@ -570,7 +595,7 @@ class MiningModeConfig(MinerConfigOption):
         if mode_settings["preset"] == "disabled":
             return MiningModeManual.from_vnish(mode_settings)
         else:
-            return cls.power_tuning(power=int(mode_settings["preset"]))
+            return MiningModePreset.from_vnish(mode_settings, web_presets)
 
     @classmethod
     def from_boser(cls, grpc_miner_conf: dict):
@@ -673,5 +698,6 @@ MiningMode = TypeVar(
         MiningModeManual,
         MiningModePowerTune,
         MiningModeHashrateTune,
+        MiningModePreset,
     ],
 )

pyasic/config/mining/presets.py

@@ -0,0 +1,34 @@
+from pyasic.config.base import MinerConfigValue
+
+
+class MiningPreset(MinerConfigValue):
+    name: str | None = None
+    power: int | None = None
+    hashrate: int | None = None
+    tuned: bool | None = None
+    modded_psu: bool = False
+
+    def as_vnish(self) -> dict:
+        if self.name is not None:
+            return {"preset": self.name}
+        return {}
+
+    @classmethod
+    def from_vnish(cls, web_preset: dict):
+        name = web_preset["name"]
+        hr_power_split = web_preset["pretty"].split("~")
+        if len(hr_power_split) == 1:
+            power = None
+            hashrate = None
+        else:
+            power = hr_power_split[0].replace("watt", "").strip()
+            hashrate = hr_power_split[1].replace("TH", "").replace(" LC", "").strip()
+        tuned = web_preset["status"] == "tuned"
+        modded_psu = web_preset["modded_psu_required"]
+        return cls(
+            name=name,
+            power=power,
+            hashrate=hashrate,
+            tuned=tuned,
+            modded_psu=modded_psu,
+        )

pyasic/data/__init__.py

@@ -96,7 +96,7 @@ class MinerData(BaseModel):
     expected_fans: int | None = None
 
     # temperature
-    env_temp: int | None = None
+    env_temp: float | None = None
 
     # power
     wattage: int | None = None

pyasic/device/algorithm/hashrate/base.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 
 from pydantic import BaseModel
 from typing_extensions import Self
 
-from .unit.base import AlgoHashRateUnitType
+from .unit.base import AlgoHashRateUnitType, GenericUnit
 
 
 class AlgoHashRateType(BaseModel, ABC):
@@ -27,36 +29,43 @@ class AlgoHashRateType(BaseModel, ABC):
         return round(self.rate, n)
 
     def __add__(self, other: Self | int | float) -> Self:
-        if isinstance(other, self.__class__):
+        if isinstance(other, AlgoHashRateType):
             return self.__class__(
                 rate=self.rate + other.into(self.unit).rate, unit=self.unit
             )
         return self.__class__(rate=self.rate + other, unit=self.unit)
 
     def __sub__(self, other: Self | int | float) -> Self:
-        if isinstance(other, self.__class__):
+        if isinstance(other, AlgoHashRateType):
             return self.__class__(
                 rate=self.rate - other.into(self.unit).rate, unit=self.unit
             )
         return self.__class__(rate=self.rate - other, unit=self.unit)
 
     def __truediv__(self, other: Self | int | float) -> Self:
-        if isinstance(other, self.__class__):
+        if isinstance(other, AlgoHashRateType):
             return self.__class__(
                 rate=self.rate / other.into(self.unit).rate, unit=self.unit
             )
         return self.__class__(rate=self.rate / other, unit=self.unit)
 
     def __floordiv__(self, other: Self | int | float) -> Self:
-        if isinstance(other, self.__class__):
+        if isinstance(other, AlgoHashRateType):
             return self.__class__(
                 rate=self.rate // other.into(self.unit).rate, unit=self.unit
             )
         return self.__class__(rate=self.rate // other, unit=self.unit)
 
     def __mul__(self, other: Self | int | float) -> Self:
-        if isinstance(other, self.__class__):
+        if isinstance(other, AlgoHashRateType):
             return self.__class__(
                 rate=self.rate * other.into(self.unit).rate, unit=self.unit
             )
         return self.__class__(rate=self.rate * other, unit=self.unit)
+
+
+class GenericHashrate(AlgoHashRateType):
+    def into(self, other: GenericUnit):
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/unit/base.py

@@ -53,3 +53,16 @@ class AlgoHashRateUnitType(IntEnum):
 
     def __repr__(self):
         return str(self)
+
+
+class GenericUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = H

pyasic/device/algorithm/hashrate/unit/scrypt.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from enum import IntEnum
+from .base import AlgoHashRateUnitType
 
 
-class ScryptUnit(IntEnum):
+class ScryptUnit(AlgoHashRateUnitType):
     H = 1
     KH = int(H) * 1000
     MH = int(KH) * 1000

pyasic/device/models.py

@@ -22,6 +22,7 @@ class AntminerModels(MinerModelType):
     S9j = "S9j"
     T9 = "T9"
     D9 = "D9"
+    L9 = "L9"
     Z15 = "Z15"
     Z15Pro = "Z15 Pro"
     S17 = "S17"
@@ -295,6 +296,7 @@ class AvalonminerModels(MinerModelType):
     Avalon1047 = "Avalon 1047"
     Avalon1066 = "Avalon 1066"
     Avalon1166Pro = "Avalon 1166 Pro"
+    Avalon1126Pro = "Avalon 1126 Pro"
     Avalon1246 = "Avalon 1246"
     AvalonNano3 = "Avalon Nano 3"
 

pyasic/miners/antminer/bmminer/X9/L9.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 AntminerModern
+from pyasic.miners.device.models import L9
+
+
+class BMMinerL9(AntminerModern, L9):
+    pass

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

@@ -16,5 +16,6 @@
 
 from .D9 import BMMinerD9
 from .E9 import BMMinerE9Pro
+from .L9 import BMMinerL9
 from .S9 import BMMinerS9, BMMinerS9i, BMMinerS9j
 from .T9 import BMMinerT9

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

@@ -14,7 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from pyasic.miners.backends import Hiveon
+from pyasic.miners.backends import HiveonModern
 from pyasic.miners.device.models import (
     S19,
     S19L,
@@ -35,65 +35,65 @@ from pyasic.miners.device.models import (
 )
 
 
-class HiveonS19(Hiveon, S19):
+class HiveonS19(HiveonModern, S19):
     pass
 
 
-class HiveonS19Plus(Hiveon, S19Plus):
+class HiveonS19Plus(HiveonModern, S19Plus):
     pass
 
 
-class HiveonS19i(Hiveon, S19i):
+class HiveonS19i(HiveonModern, S19i):
     pass
 
 
-class HiveonS19Pro(Hiveon, S19Pro):
+class HiveonS19Pro(HiveonModern, S19Pro):
     pass
 
 
-class HiveonS19ProPlus(Hiveon, S19ProPlus):
+class HiveonS19ProPlus(HiveonModern, S19ProPlus):
     pass
 
 
-class HiveonS19XP(Hiveon, S19XP):
+class HiveonS19XP(HiveonModern, S19XP):
     pass
 
 
-class HiveonS19a(Hiveon, S19a):
+class HiveonS19a(HiveonModern, S19a):
     pass
 
 
-class HiveonS19aPro(Hiveon, S19aPro):
+class HiveonS19aPro(HiveonModern, S19aPro):
     pass
 
 
-class HiveonS19j(Hiveon, S19j):
+class HiveonS19j(HiveonModern, S19j):
     pass
 
 
-class HiveonS19jNoPIC(Hiveon, S19jNoPIC):
+class HiveonS19jNoPIC(HiveonModern, S19jNoPIC):
     pass
 
 
-class HiveonS19jPro(Hiveon, S19jPro):
+class HiveonS19jPro(HiveonModern, S19jPro):
     pass
 
 
-class HiveonS19L(Hiveon, S19L):
+class HiveonS19L(HiveonModern, S19L):
     pass
 
 
-class HiveonS19ProHydro(Hiveon, S19ProHydro):
+class HiveonS19ProHydro(HiveonModern, S19ProHydro):
     pass
 
 
-class HiveonS19Hydro(Hiveon, S19Hydro):
+class HiveonS19Hydro(HiveonModern, S19Hydro):
     pass
 
 
-class HiveonS19ProPlusHydro(Hiveon, S19ProPlusHydro):
+class HiveonS19ProPlusHydro(HiveonModern, S19ProPlusHydro):
     pass
 
 
-class HiveonS19KPro(Hiveon, S19KPro):
+class HiveonS19KPro(HiveonModern, S19KPro):
     pass

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

@@ -14,9 +14,9 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from pyasic.miners.backends import Hiveon
+from pyasic.miners.backends import HiveonModern
 from pyasic.miners.device.models import T19
 
 
-class HiveonT19(Hiveon, T19):
+class HiveonT19(HiveonModern, T19):
     pass

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

@@ -21,7 +21,7 @@ import asyncssh
 from pyasic.data import HashBoard
 from pyasic.device.algorithm import AlgoHashRate, HashUnit
 from pyasic.errors import APIError
-from pyasic.miners.backends import Hiveon
+from pyasic.miners.backends import HiveonOld
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.models import T9
 
@@ -71,7 +71,7 @@ HIVEON_T9_DATA_LOC = DataLocations(
 )
 
 
-class HiveonT9(Hiveon, T9):
+class HiveonT9(HiveonOld, T9):
     data_locations = HIVEON_T9_DATA_LOC
 
     ##################################################

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

@@ -22,6 +22,7 @@ from pyasic.miners.device.models import (
     S19aPro,
     S19j,
     S19jPro,
+    S19kPro,
     S19NoPIC,
     S19Pro,
     S19ProHydro,
@@ -62,3 +63,7 @@ class VNishS19jPro(VNish, S19jPro):
 
 class VNishS19ProHydro(VNish, S19ProHydro):
     pass
+
+
+class VNishS19kPro(VNish, S19kPro):
+    pass

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

@@ -20,6 +20,7 @@ from .S19 import (
     VNishS19aPro,
     VNishS19j,
     VNishS19jPro,
+    VNishS19kPro,
     VNishS19NoPIC,
     VNishS19Pro,
     VNishS19ProHydro,

pyasic/miners/avalonminer/cgminer/A11X/A1126.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 AvalonMiner
+from pyasic.miners.device.models import Avalon1126Pro
+
+
+class CGMinerAvalon1126Pro(AvalonMiner, Avalon1126Pro):
+    pass

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

@@ -14,4 +14,5 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+from .A1126 import CGMinerAvalon1126Pro
 from .A1166 import CGMinerAvalon1166Pro

pyasic/miners/backends/__init__.py

@@ -25,7 +25,7 @@ from .cgminer import CGMiner
 from .epic import ePIC
 from .goldshell import GoldshellMiner
 from .hammer import BlackMiner
-from .hiveon import Hiveon
+from .hiveon import HiveonModern, HiveonOld
 from .iceriver import IceRiver
 from .innosilicon import Innosilicon
 from .luxminer import LUXMiner

pyasic/miners/backends/braiins_os.py

@@ -746,7 +746,7 @@ class BOSer(BraiinsOSFirmware):
     """Handler for new versions of BraiinsOS+ (post-gRPC)"""
 
     _rpc_cls = BOSMinerRPCAPI
-    web: BOSMinerRPCAPI
+    rpc: BOSMinerRPCAPI
     _web_cls = BOSerWebAPI
     web: BOSerWebAPI
 

pyasic/miners/backends/hiveon.py

@@ -16,13 +16,28 @@
 from typing import Optional
 
 from pyasic import APIError
+from pyasic.config import MinerConfig, MiningModeConfig
 from pyasic.miners.backends import BMMiner
-from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
+from pyasic.miners.data import (
+    DataFunction,
+    DataLocations,
+    DataOptions,
+    RPCAPICommand,
+    WebAPICommand,
+)
 from pyasic.miners.device.firmware import HiveonFirmware
 from pyasic.web.hiveon import HiveonWebAPI
 
-HIVEON_DATA_LOC = DataLocations(
+HIVEON_MODERN_DATA_LOC = DataLocations(
     **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_get_system_info", "get_system_info")],
+        ),
+        str(DataOptions.HOSTNAME): DataFunction(
+            "_get_hostname",
+            [WebAPICommand("web_get_system_info", "get_system_info")],
+        ),
         str(DataOptions.API_VERSION): DataFunction(
             "_get_api_ver",
             [RPCAPICommand("rpc_version", "version")],
@@ -59,16 +74,194 @@ HIVEON_DATA_LOC = DataLocations(
             "_get_pools",
             [RPCAPICommand("rpc_pools", "pools")],
         ),
+        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_conf", "get_miner_conf")],
+        ),
     }
 )
 
 
-class Hiveon(HiveonFirmware, BMMiner):
-    data_locations = HIVEON_DATA_LOC
+class HiveonModern(HiveonFirmware, BMMiner):
+    data_locations = HIVEON_MODERN_DATA_LOC
 
     web: HiveonWebAPI
     _web_cls = HiveonWebAPI
 
+    async def get_config(self) -> MinerConfig:
+        data = await self.web.get_miner_conf()
+        if data:
+            self.config = MinerConfig.from_hiveon_modern(data)
+        return self.config
+
+    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 stop_mining(self) -> bool:
+        cfg = await self.get_config()
+        cfg.miner_mode = MiningModeConfig.sleep()
+        await self.send_config(cfg)
+        return True
+
+    async def resume_mining(self) -> bool:
+        cfg = await self.get_config()
+        cfg.miner_mode = MiningModeConfig.normal()
+        await self.send_config(cfg)
+        return True
+
+    async def _get_wattage(self, rpc_stats: dict = None) -> Optional[int]:
+        if not rpc_stats:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats:
+            boards = rpc_stats.get("STATS")
+            try:
+                wattage_raw = boards[1]["chain_power"]
+            except (KeyError, IndexError):
+                pass
+            else:
+                # parse wattage position out of raw data
+                return round(float(wattage_raw.split(" ")[0]))
+
+    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_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 _is_mining(self, web_get_conf: dict = None) -> Optional[bool]:
+        if web_get_conf is None:
+            try:
+                web_get_conf = await self.web.get_miner_conf()
+            except APIError:
+                pass
+
+        if web_get_conf is not None:
+            try:
+                if str(web_get_conf["bitmain-work-mode"]).isdigit():
+                    return (
+                        False if int(web_get_conf["bitmain-work-mode"]) == 1 else True
+                    )
+                return False
+            except LookupError:
+                pass
+
+
+HIVEON_OLD_DATA_LOC = DataLocations(
+    **{
+        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_summary", "summary")],
+        ),
+        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
+            "_get_expected_hashrate",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
+        str(DataOptions.WATTAGE): DataFunction(
+            "_get_wattage",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+    }
+)
+
+
+class HiveonOld(HiveonFirmware, BMMiner):
+    data_locations = HIVEON_OLD_DATA_LOC
+
     async def _get_wattage(self, rpc_stats: dict = None) -> Optional[int]:
         if not rpc_stats:
             try:

pyasic/miners/backends/vnish.py

@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+import logging
 from typing import Optional
 
 from pyasic import MinerConfig
@@ -95,6 +96,8 @@ class VNish(VNishFirmware, BMMiner):
     web: VNishWebAPI
 
     supports_shutdown = True
+    supports_presets = True
+    supports_autotuning = True
 
     data_locations = VNISH_DATA_LOC
 
@@ -266,7 +269,32 @@ class VNish(VNishFirmware, BMMiner):
     async def get_config(self) -> MinerConfig:
         try:
             web_settings = await self.web.settings()
+            web_presets = await self.web.autotune_presets()
         except APIError:
             return self.config
-        self.config = MinerConfig.from_vnish(web_settings)
+        self.config = MinerConfig.from_vnish(web_settings, web_presets)
         return self.config
+
+    async def set_power_limit(self, wattage: int) -> bool:
+        config = await self.get_config()
+        valid_presets = [
+            preset.power
+            for preset in config.mining_mode.available_presets
+            if preset.tuned and preset.power <= wattage
+        ]
+        new_wattage = max(valid_presets)
+
+        # Set power to highest preset <= wattage
+        try:
+            await self.web.set_power_limit(new_wattage)
+            updated_settings = await self.web.settings()
+        except APIError:
+            raise
+        except Exception as e:
+            logging.warning(f"{self} - Failed to set power limit: {e}")
+            return False
+
+        if int(updated_settings["miner"]["overclock"]["preset"]) == new_wattage:
+            return True
+        else:
+            return False

pyasic/miners/base.py

@@ -56,6 +56,7 @@ class MinerProtocol(Protocol):
 
     supports_shutdown: bool = False
     supports_power_modes: bool = False
+    supports_presets: bool = False
     supports_autotuning: bool = False
 
     api_ver: str = None

pyasic/miners/device/models/antminer/X9/L9.py

@@ -0,0 +1,27 @@
+# ------------------------------------------------------------------------------
+#  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.device.algorithm import MinerAlgo
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class L9(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.L9
+
+    expected_chips = 110
+    expected_hashboards = 3
+    expected_fans = 4
+    algo = MinerAlgo.SCRYPT

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

@@ -16,5 +16,6 @@
 
 from .D9 import D9
 from .E9 import E9Pro
+from .L9 import L9
 from .S9 import S9, S9i, S9j
 from .T9 import T9

pyasic/miners/device/models/avalonminer/A11X/A1126.py

@@ -0,0 +1,27 @@
+# ------------------------------------------------------------------------------
+#  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.device.algorithm import MinerAlgo
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AvalonMinerMake
+
+
+class Avalon1126Pro(AvalonMinerMake):
+    raw_model = MinerModel.AVALONMINER.Avalon1126Pro
+
+    expected_chips = 120
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256

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

@@ -15,4 +15,5 @@
 # ------------------------------------------------------------------------------
 
 
+from .A1126 import Avalon1126Pro
 from .A1166 import Avalon1166Pro

pyasic/miners/factory.py

@@ -80,6 +80,7 @@ MINER_CLASSES = {
         "ANTMINER S9I": BMMinerS9i,
         "ANTMINER S9J": BMMinerS9j,
         "ANTMINER T9": BMMinerT9,
+        "ANTMINER L9": BMMinerL9,
         "ANTMINER Z15": CGMinerZ15,
         "ANTMINER Z15 PRO": BMMinerZ15Pro,
         "ANTMINER S17": BMMinerS17,
@@ -339,6 +340,7 @@ MINER_CLASSES = {
         "AVALONMINER 1026": CGMinerAvalon1026,
         "AVALONMINER 1047": CGMinerAvalon1047,
         "AVALONMINER 1066": CGMinerAvalon1066,
+        "AVALONMINER 1126PRO": CGMinerAvalon1126Pro,
         "AVALONMINER 1166PRO": CGMinerAvalon1166Pro,
         "AVALONMINER 1246": CGMinerAvalon1246,
         "AVALONMINER NANO3": CGMinerAvalonNano3,
@@ -405,6 +407,7 @@ MINER_CLASSES = {
         "ANTMINER S19A": VNishS19a,
         "ANTMINER S19A PRO": VNishS19aPro,
         "ANTMINER S19 PRO HYD.": VNishS19ProHydro,
+        "ANTMINER S19K PRO": VNishS19kPro,
         "ANTMINER T19": VNishT19,
         "ANTMINER S21": VNishS21,
     },
@@ -424,9 +427,10 @@ MINER_CLASSES = {
         "BLOCKMINER 720I": ePICBlockMiner720i,
     },
     MinerTypes.HIVEON: {
-        None: Hiveon,
+        None: HiveonModern,
         "ANTMINER T9": HiveonT9,
         "ANTMINER S19JPRO": HiveonS19jPro,
+        "ANTMINER S19": HiveonS19,
     },
     MinerTypes.LUX_OS: {
         None: LUXMiner,
@@ -864,7 +868,7 @@ class MinerFactory:
         miner_type: MinerTypes | None,
     ) -> AnyMiner | None:
         # special case since hiveon miners return web results copying the antminer stock FW
-        if "HIVEON" in str(miner_model).upper() and miner_type == MinerTypes.ANTMINER:
+        if "HIVEON" in str(miner_model).upper():
             miner_model = str(miner_model).upper().replace(" HIVEON", "")
             miner_type = MinerTypes.HIVEON
         try:
@@ -873,7 +877,7 @@ class MinerFactory:
             if miner_type in MINER_CLASSES:
                 if miner_model is not None:
                     warnings.warn(
-                        f"Partially supported miner found: {miner_model}, please open an issue with miner data "
+                        f"Partially supported miner found: {miner_model}, type: {miner_type}, please open an issue with miner data "
                         f"and this model on GitHub (https://github.com/UpstreamData/pyasic/issues)."
                     )
                 return MINER_CLASSES[miner_type][None](ip)

pyasic/settings/__init__.py

@@ -37,7 +37,7 @@ _settings = {  # defaults
     "default_goldshell_web_password": "123456789",
     "default_auradine_web_password": "admin",
     "default_epic_web_password": "letmein",
-    "default_hive_web_password": "admin",
+    "default_hive_web_password": "root",
     "default_iceriver_web_password": "12345678",
     "default_antminer_ssh_password": "miner",
     "default_bosminer_ssh_password": "root",

pyasic/web/vnish.py

@@ -138,6 +138,15 @@ class VNishWebAPI(BaseWebAPI):
     async def settings(self) -> dict:
         return await self.send_command("settings")
 
+    async def set_power_limit(self, wattage: int) -> bool:
+        # Can only set power limit to tuned preset
+        settings = await self.settings()
+        settings["miner"]["overclock"]["preset"] = str(wattage)
+        new_settings = {"miner": {"overclock": settings["miner"]["overclock"]}}
+
+        # response will always be {"restart_required":false,"reboot_required":false} even if unsuccessful
+        return await self.send_command("settings", privileged=True, **new_settings)
+
     async def autotune_presets(self) -> dict:
         return await self.send_command("autotune/presets")
 

pyproject.toml

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