docs: update supported miners

Signed-off-by: James Hilliard <james.hilliard1@gmail.com>

docs/generate_miners.py

@@ -51,6 +51,8 @@ def backend_str(backend: MinerTypes) -> str:
             return "Mara Firmware Miners"
         case MinerTypes.BITAXE:
             return "Stock Firmware BitAxe Miners"
+        case MinerTypes.ICERIVER:
+            return "Stock Firmware IceRiver Miners"
 
 
 def create_url_str(mtype: str):

docs/miners/antminer/X19.md

@@ -225,6 +225,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S19 Pro+ Hydro (BOS+)
+::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19ProPlusHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## T19 (BOS+)
 ::: pyasic.miners.antminer.bosminer.X19.T19.BOSMinerT19
     handler: python
@@ -281,6 +288,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S19 Pro Hydro (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19ProHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## T19 (VNish)
 ::: pyasic.miners.antminer.vnish.X19.T19.VNishT19
     handler: python

docs/miners/antminer/X21.md

@@ -8,6 +8,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S21 Pro (Stock)
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## T21 (Stock)
 ::: pyasic.miners.antminer.bmminer.X21.T21.BMMinerT21
     handler: python
@@ -22,6 +29,13 @@
         show_root_heading: false
         heading_level: 4
 
+## T21 (BOS+)
+::: pyasic.miners.antminer.bosminer.X21.T21.BOSMinerT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## S21 (VNish)
 ::: pyasic.miners.antminer.vnish.X21.S21.VNishS21
     handler: python
@@ -36,6 +50,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S21 Pro (ePIC)
+::: pyasic.miners.antminer.epic.X21.S21.ePICS21Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## T21 (ePIC)
 ::: pyasic.miners.antminer.epic.X21.T21.ePICT21
     handler: python

docs/miners/antminer/X3.md

@@ -22,6 +22,20 @@
         show_root_heading: false
         heading_level: 4
 
+## KA3 (Stock)
+::: pyasic.miners.antminer.bmminer.X3.KA3.BMMinerKA3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+::: pyasic.miners.antminer.bmminer.X3.KS3.BMMinerKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## L3+ (VNish)
 ::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
     handler: python

docs/miners/antminer/X5.md

@@ -8,3 +8,10 @@
         show_root_heading: false
         heading_level: 4
 
+## KS5 (Stock)
+::: pyasic.miners.antminer.bmminer.X5.KS5.BMMinerKS5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/iceriver/KSX.md

@@ -0,0 +1,45 @@
+# pyasic
+## KSX Models
+
+## KS0 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS0.IceRiverKS0
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS1 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS1.IceRiverKS1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS2 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS2.IceRiverKS2
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3L (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3M (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/supported_types.md

@@ -21,12 +21,15 @@ details {
                     <li><a href="../antminer/X3#d3-stock">D3 (Stock)</a></li>
                     <li><a href="../antminer/X3#hs3-stock">HS3 (Stock)</a></li>
                     <li><a href="../antminer/X3#l3_1-stock">L3+ (Stock)</a></li>
+                    <li><a href="../antminer/X3#ka3-stock">KA3 (Stock)</a></li>
+                    <li><a href="../antminer/X3#ks3-stock">KS3 (Stock)</a></li>
                 </ul>
         </details>
         <details>
             <summary>X5 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X5#dr5-stock">DR5 (Stock)</a></li>
+                    <li><a href="../antminer/X5#ks5-stock">KS5 (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -89,6 +92,7 @@ details {
             <summary>X21 Series:</summary>
                 <ul>
                     <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>
                 </ul>
         </details>
@@ -377,6 +381,12 @@ details {
                     <li><a href="../avalonminer/A12X#avalon-1246-stock">Avalon 1246 (Stock)</a></li>
                 </ul>
         </details>
+        <details>
+            <summary>nano Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/nano#avalon-nano-3-stock">Avalon Nano 3 (Stock)</a></li>
+                </ul>
+        </details>
     </ul>
 </details>
 <details>
@@ -394,6 +404,12 @@ details {
                     <li><a href="../innosilicon/A10X#a10x-stock">A10X (Stock)</a></li>
                 </ul>
         </details>
+        <details>
+            <summary>A11X Series:</summary>
+                <ul>
+                    <li><a href="../innosilicon/A11X#a11mx-stock">A11MX (Stock)</a></li>
+                </ul>
+        </details>
     </ul>
 </details>
 <details>
@@ -461,6 +477,7 @@ details {
                     <li><a href="../antminer/X19#s19k-pro-no-pic-bos_1">S19k Pro No PIC (BOS+)</a></li>
                     <li><a href="../antminer/X19#s19k-pro-no-pic-bos_1">S19k Pro No PIC (BOS+)</a></li>
                     <li><a href="../antminer/X19#s19-xp-bos_1">S19 XP (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19-pro_1-hydro-bos_1">S19 Pro+ Hydro (BOS+)</a></li>
                     <li><a href="../antminer/X19#t19-bos_1">T19 (BOS+)</a></li>
                 </ul>
         </details>
@@ -468,6 +485,7 @@ details {
             <summary>X21 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X21#s21-bos_1">S21 (BOS+)</a></li>
+                    <li><a href="../antminer/X21#t21-bos_1">T21 (BOS+)</a></li>
                 </ul>
         </details>
     </ul>
@@ -505,6 +523,7 @@ details {
                     <li><a href="../antminer/X19#s19j-pro-vnish">S19j Pro (VNish)</a></li>
                     <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#t19-vnish">T19 (VNish)</a></li>
                 </ul>
         </details>
@@ -535,6 +554,7 @@ details {
             <summary>X21 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X21#s21-epic">S21 (ePIC)</a></li>
+                    <li><a href="../antminer/X21#s21-pro-epic">S21 Pro (ePIC)</a></li>
                     <li><a href="../antminer/X21#t21-epic">T21 (ePIC)</a></li>
                 </ul>
         </details>
@@ -650,4 +670,20 @@ details {
                 </ul>
         </details>
     </ul>
+</details>
+<details>
+<summary>Stock Firmware IceRiver Miners:</summary>
+    <ul>
+        <details>
+            <summary>KSX Series:</summary>
+                <ul>
+                    <li><a href="../iceriver/KSX#ks0-stock">KS0 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks1-stock">KS1 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks2-stock">KS2 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks3-stock">KS3 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks3l-stock">KS3L (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks3m-stock">KS3M (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
 </details>

docs/settings/settings.md

@@ -24,7 +24,6 @@ Settings options:
 - `default_hive_web_password`
 - `default_antminer_ssh_password`
 - `default_bosminer_ssh_password`
-- `socket_linger_time`
 
 
 ### get

pyasic/config/mining/__init__.py

@@ -198,7 +198,7 @@ class MiningModePowerTune(MinerConfigValue):
     def as_boser(self) -> dict:
         cfg = {
             "set_performance_mode": SetPerformanceModeRequest(
-                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                save_action=SaveAction.SAVE_AND_APPLY,
                 mode=PerformanceMode(
                     tuner_mode=TunerPerformanceMode(
                         power_target=PowerTargetMode(
@@ -275,7 +275,7 @@ class MiningModeHashrateTune(MinerConfigValue):
     def as_boser(self) -> dict:
         cfg = {
             "set_performance_mode": SetPerformanceModeRequest(
-                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                save_action=SaveAction.SAVE_AND_APPLY,
                 mode=PerformanceMode(
                     tuner_mode=TunerPerformanceMode(
                         hashrate_target=HashrateTargetMode(

pyasic/config/pools.py

@@ -467,7 +467,7 @@ class PoolConfig(MinerConfigValue):
     def as_boser(self, user_suffix: str = None) -> dict:
         return {
             "set_pool_groups": SetPoolGroupsRequest(
-                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                save_action=SaveAction.SAVE_AND_APPLY,
                 pool_groups=[g.as_boser(user_suffix=user_suffix) for g in self.groups],
             )
         }

pyasic/data/pools.py

@@ -7,6 +7,7 @@ from urllib.parse import urlparse
 class Scheme(Enum):
     STRATUM_V1 = "stratum+tcp"
     STRATUM_V2 = "stratum2+tcp"
+    STRATUM_V1_SSL = "stratum+ssl"
 
 
 @dataclass
@@ -25,7 +26,10 @@ class PoolUrl:
     @classmethod
     def from_str(cls, url: str) -> "PoolUrl":
         parsed_url = urlparse(url)
-        scheme = Scheme(parsed_url.scheme)
+        if not parsed_url.scheme.strip() == "":
+            scheme = Scheme(parsed_url.scheme)
+        else:
+            scheme = Scheme.STRATUM_V1
         host = parsed_url.hostname
         port = parsed_url.port
         pubkey = parsed_url.path.lstrip("/") if scheme == Scheme.STRATUM_V2 else None

pyasic/device/makes.py

@@ -26,6 +26,7 @@ class MinerMake(str, Enum):
     AURADINE = "Auradine"
     EPIC = "ePIC"
     BITAXE = "BitAxe"
+    ICERIVER = "IceRiver"
 
     def __str__(self):
         return self.value

pyasic/device/models.py

@@ -5,7 +5,10 @@ class AntminerModels(str, Enum):
     D3 = "D3"
     HS3 = "HS3"
     L3Plus = "L3+"
+    KA3 = "KA3"
+    KS3 = "KS3"
     DR5 = "DR5"
+    KS5 = "KS5"
     L7 = "L7"
     E9Pro = "E9Pro"
     S9 = "S9"
@@ -44,6 +47,7 @@ class AntminerModels(str, Enum):
     S19kProNoPIC = "S19k Pro No PIC"
     T19 = "T19"
     S21 = "S21"
+    S21Pro = "S21 Pro"
     T21 = "T21"
 
     def __str__(self):
@@ -283,6 +287,7 @@ class AvalonminerModels(str, Enum):
     Avalon1066 = "Avalon 1066"
     Avalon1166Pro = "Avalon 1166 Pro"
     Avalon1246 = "Avalon 1246"
+    AvalonNano3 = "Avalon Nano 3"
 
     def __str__(self):
         return self.value
@@ -291,6 +296,7 @@ class AvalonminerModels(str, Enum):
 class InnosiliconModels(str, Enum):
     T3HPlus = "T3H+"
     A10X = "A10X"
+    A11MX = "A11MX"
 
     def __str__(self):
         return self.value
@@ -338,6 +344,18 @@ class BitAxeModels(str, Enum):
         return self.value
 
 
+class IceRiverModels(str, Enum):
+    KS0 = "KS0"
+    KS1 = "KS1"
+    KS2 = "KS2"
+    KS3 = "KS3"
+    KS3L = "KS3L"
+    KS3M = "KS3M"
+
+    def __str__(self):
+        return self.value
+
+
 class MinerModel:
     ANTMINER = AntminerModels
     WHATSMINER = WhatsminerModels
@@ -347,3 +365,4 @@ class MinerModel:
     AURADINE = AuradineModels
     EPIC = ePICModels
     BITAXE = BitAxeModels
+    ICERIVER = IceRiverModels

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

@@ -15,8 +15,12 @@
 # ------------------------------------------------------------------------------
 
 from pyasic.miners.backends import AntminerModern
-from pyasic.miners.device.models import S21
+from pyasic.miners.device.models import S21, S21Pro
 
 
 class BMMinerS21(AntminerModern, S21):
     pass
+
+
+class BMMinerS21Pro(AntminerModern, S21Pro):
+    pass

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
+from .S21 import BMMinerS21, BMMinerS21Pro
 from .T21 import BMMinerT21

pyasic/miners/antminer/bmminer/X3/KA3.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 KA3
+
+
+class BMMinerKA3(AntminerModern, KA3):
+    pass

pyasic/miners/antminer/bmminer/X3/KS3.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.antminer import KS3
+
+
+class BMMinerKS3(AntminerModern, KS3):
+    pass

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

@@ -14,4 +14,6 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from .HS3 import BMMinerHS3
+from .KA3 import BMMinerKA3
+from .KS3 import BMMinerKS3
 from .L3 import BMMinerL3Plus

pyasic/miners/antminer/bmminer/X5/KS5.py

@@ -0,0 +1,21 @@
+# ------------------------------------------------------------------------------
+#  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 KS5
+
+
+class BMMinerKS5(AntminerModern, KS5):
+    supports_shutdown = False

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

@@ -0,0 +1,16 @@
+# ------------------------------------------------------------------------------
+#  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 .KS5 import BMMinerKS5

pyasic/miners/antminer/bmminer/__init__.py

@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from .X3 import *
+from .X5 import *
 from .X7 import *
 from .X9 import *
 from .X17 import *

pyasic/miners/antminer/bosminer/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 BOSer
+from pyasic.miners.device.models import T21
+
+
+class BOSMinerT21(BOSer, T21):
+    pass

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

@@ -15,3 +15,4 @@
 # ------------------------------------------------------------------------------
 
 from .S21 import BOSMinerS21
+from .T21 import BOSMinerT21

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

@@ -15,8 +15,12 @@
 # ------------------------------------------------------------------------------
 
 from pyasic.miners.backends import ePIC
-from pyasic.miners.device.models import S21
+from pyasic.miners.device.models import S21, S21Pro
 
 
 class ePICS21(ePIC, S21):
     pass
+
+
+class ePICS21Pro(ePIC, S21Pro):
+    pass

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

@@ -14,9 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from .S21 import (
-    ePICS21,
-)
+from .S21 import ePICS21, ePICS21Pro
 
 from .T21 import (
     ePICT21,

pyasic/miners/avalonminer/cgminer/__init__.py

@@ -20,3 +20,4 @@ from .A9X import *
 from .A10X import *
 from .A11X import *
 from .A12X import *
+from .nano import *

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

@@ -0,0 +1,17 @@
+# ------------------------------------------------------------------------------
+#  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 .nano3 import CGMinerAvalonNano3

pyasic/miners/avalonminer/cgminer/nano/nano3.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 AvalonNano3
+
+
+class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
+    pass

pyasic/miners/backends/__init__.py

@@ -24,6 +24,7 @@ from .cgminer import CGMiner
 from .epic import ePIC
 from .goldshell import GoldshellMiner
 from .hiveon import Hiveon
+from .iceriver import IceRiver
 from .innosilicon import Innosilicon
 from .luxminer import LUXMiner
 from .marathon import MaraMiner

pyasic/miners/backends/antminer.py

@@ -14,6 +14,8 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+import logging
+from pathlib import Path
 from typing import List, Optional, Union
 
 from pyasic.config import MinerConfig, MiningModeConfig
@@ -124,6 +126,41 @@ class AntminerModern(BMMiner):
         #         break
         #     await asyncio.sleep(1)
 
+    async def upgrade_firmware(self, file: Path, keep_settings: bool = True) -> str:
+        """
+        Upgrade the firmware of the AntMiner device.
+
+        Args:
+            file (Path): Path to the firmware file.
+            keep_settings (bool): Whether to keep the current settings after the update.
+
+        Returns:
+            str: Result of the upgrade process.
+        """
+        if not file:
+            raise ValueError("File location must be provided for firmware upgrade.")
+
+        try:
+            result = await self.web.update_firmware(
+                file=file, keep_settings=keep_settings
+            )
+
+            if result.get("success"):
+                logging.info(
+                    "Firmware upgrade process completed successfully for AntMiner."
+                )
+                return "Firmware upgrade completed successfully."
+            else:
+                error_message = result.get("message", "Unknown error")
+                logging.error(f"Firmware upgrade failed. Response: {error_message}")
+                return f"Firmware upgrade failed. Response: {error_message}"
+        except Exception as e:
+            logging.error(
+                f"An error occurred during the firmware upgrade process: {e}",
+                exc_info=True,
+            )
+            raise
+
     async def fault_light_on(self) -> bool:
         data = await self.web.blink(blink=True)
         if data:
@@ -337,7 +374,7 @@ class AntminerModern(BMMiner):
 
         if web_get_conf is not None:
             try:
-                if web_get_conf["bitmain-work-mode"].isdigit():
+                if str(web_get_conf["bitmain-work-mode"]).isdigit():
                     return (
                         False if int(web_get_conf["bitmain-work-mode"]) == 1 else True
                     )
@@ -427,6 +464,10 @@ ANTMINER_OLD_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 

pyasic/miners/backends/auradine.py

@@ -193,6 +193,40 @@ class Auradine(StockFirmware):
         for key in conf.keys():
             await self.web.send_command(command=key, **conf[key])
 
+    async def upgrade_firmware(self, *, url: str = None, version: str = "latest", keep_settings: bool = False, **kwargs) -> bool:
+        """
+        Upgrade the firmware of the Auradine device.
+
+        Args:
+            url (str): The URL to download the firmware from.
+            version (str): The version of the firmware to upgrade to.
+            keep_settings (bool): Whether to keep the current settings during the upgrade.
+
+        Returns:
+            bool: True if the firmware upgrade was successful, False otherwise.
+        """
+        try:
+            logging.info("Starting firmware upgrade process.")
+
+            if not url and not version:
+                raise ValueError("Either URL or version must be provided for firmware upgrade.")
+
+            if url:
+                result = await self.web.firmware_upgrade(url=url)
+            else:
+                result = await self.web.firmware_upgrade(version=version)
+
+            if result.get("STATUS", [{}])[0].get("STATUS") == "S":
+                logging.info("Firmware upgrade process completed successfully.")
+                return True
+            else:
+                logging.error(f"Firmware upgrade failed: {result.get('error', 'Unknown error')}")
+                return False
+
+        except Exception as e:
+            logging.error(f"An error occurred during the firmware upgrade process: {str(e)}")
+            return False
+
     ##################################################
     ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
     ##################################################

pyasic/miners/backends/avalonminer.py

@@ -68,6 +68,10 @@ AVALON_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 
@@ -114,7 +118,7 @@ class AvalonMiner(CGMiner):
         stats_items = []
         stats_dict = {}
         for item in _stats_items:
-            if ":" in item:
+            if ": " in item:
                 data = item.replace("]", "").split("[")
                 data_list = [i.split(": ") for i in data[1].strip().split(", ")]
                 data_dict = {}
@@ -143,10 +147,7 @@ class AvalonMiner(CGMiner):
             if raw_data[0] == "":
                 raw_data = raw_data[1:]
 
-            if len(raw_data) == 2:
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
+            stats_dict[raw_data[0]] = raw_data[1:]
             stats_items.append(raw_data)
 
         return stats_dict
@@ -216,7 +217,7 @@ class AvalonMiner(CGMiner):
                 try:
                     board_hr = parsed_stats["MGHS"][board]
                     hashboards[board].hashrate = AlgoHashRate.SHA256(
-                        board_hr, HashUnit.SHA256.GH
+                        float(board_hr), HashUnit.SHA256.GH
                     ).into(self.algo.unit.default)
                 except LookupError:
                     pass
@@ -252,7 +253,7 @@ class AvalonMiner(CGMiner):
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
                 return AlgoHashRate.SHA256(
-                    parsed_stats["GHSmm"], HashUnit.SHA256.GH
+                    float(parsed_stats["GHSmm"][0]), HashUnit.SHA256.GH
                 ).into(self.algo.unit.default)
             except (IndexError, KeyError, ValueError, TypeError):
                 pass
@@ -268,7 +269,7 @@ class AvalonMiner(CGMiner):
             try:
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-                return float(parsed_stats["Temp"])
+                return float(parsed_stats["Temp"][0])
             except (IndexError, KeyError, ValueError, TypeError):
                 pass
 
@@ -283,7 +284,7 @@ class AvalonMiner(CGMiner):
             try:
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-                return int(parsed_stats["MPO"])
+                return int(parsed_stats["MPO"][0])
             except (IndexError, KeyError, ValueError, TypeError):
                 pass
 
@@ -304,7 +305,7 @@ class AvalonMiner(CGMiner):
 
             for fan in range(self.expected_fans):
                 try:
-                    fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"])
+                    fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"][0])
                 except (IndexError, KeyError, ValueError, TypeError):
                     pass
         return fans_data
@@ -322,7 +323,7 @@ class AvalonMiner(CGMiner):
             try:
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-                led = int(parsed_stats["Led"])
+                led = int(parsed_stats["Led"][0])
                 return True if led == 1 else False
             except (IndexError, KeyError, ValueError, TypeError):
                 pass

pyasic/miners/backends/bfgminer.py

@@ -22,6 +22,7 @@ from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
 from pyasic.rpc.bfgminer import BFGMinerRPCAPI
+from pyasic.data.pools import PoolMetrics, PoolUrl
 
 BFGMINER_DATA_LOC = DataLocations(
     **{
@@ -49,6 +50,10 @@ BFGMINER_DATA_LOC = DataLocations(
             "_get_fans",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 
@@ -207,6 +212,36 @@ class BFGMiner(StockFirmware):
 
         return fans
 
+    async def _get_pools(self, rpc_pools: dict = None) -> List[PoolMetrics]:
+        if rpc_pools is None:
+            try:
+                rpc_pools = await self.rpc.pools()
+            except APIError:
+                pass
+
+        pools_data = []
+        if rpc_pools is not None:
+            try:
+                pools = rpc_pools.get("POOLS", [])
+                for pool_info in pools:
+                    url = pool_info.get("URL")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("Accepted"),
+                        rejected=pool_info.get("Rejected"),
+                        get_failures=pool_info.get("Get Failures"),
+                        remote_failures=pool_info.get("Remote Failures"),
+                        active=pool_info.get("Stratum Active"),
+                        alive=pool_info.get("Status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("User"),
+                        index=pool_info.get("POOL"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data
+
     async def _get_expected_hashrate(
         self, rpc_stats: dict = None
     ) -> Optional[AlgoHashRate]:
@@ -228,4 +263,4 @@ class BFGMiner(StockFirmware):
                     expected_rate, HashUnit.SHA256.from_str(rate_unit)
                 ).into(self.algo.unit.default)
             except LookupError:
-                pass
+                pass

pyasic/miners/backends/bitaxe.py

@@ -41,6 +41,10 @@ BITAXE_DATA_LOC = DataLocations(
             "_get_api_ver",
             [WebAPICommand("web_system_info", "system/info")],
         ),
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_system_info", "system/info")],
+        ),
     }
 )
 
@@ -187,3 +191,16 @@ class BitAxe(BaseMiner):
                 return web_system_info["version"]
             except KeyError:
                 pass
+
+    async def _get_mac(self, web_system_info: dict = None) -> Optional[str]:
+        if web_system_info is None:
+            try:
+                web_system_info = await self.web.system_info()
+            except APIError:
+                pass
+
+        if web_system_info is not None:
+            try:
+                return web_system_info["macAddr"].upper()
+            except KeyError:
+                pass

pyasic/miners/backends/braiins_os.py

@@ -20,7 +20,12 @@ from pathlib import Path
 from typing import List, Optional, Union
 
 import aiofiles
-import toml
+import tomli_w
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
 
 from pyasic.config import MinerConfig
 from pyasic.config.mining import MiningModePowerTune
@@ -177,10 +182,10 @@ class BOSMiner(BraiinsOSFirmware):
         raw_data = await self.ssh.get_config_file()
 
         try:
-            toml_data = toml.loads(raw_data)
+            toml_data = tomllib.loads(raw_data)
             cfg = MinerConfig.from_bosminer(toml_data)
             self.config = cfg
-        except toml.TomlDecodeError as e:
+        except tomllib.TOMLDecodeError as e:
             raise APIError("Failed to decode toml when getting config.") from e
         except TypeError as e:
             raise APIError("Failed to decode toml when getting config.") from e
@@ -191,7 +196,7 @@ class BOSMiner(BraiinsOSFirmware):
         self.config = config
         parsed_cfg = config.as_bosminer(user_suffix=user_suffix)
 
-        toml_conf = toml.dumps(
+        toml_conf = tomli_w.dumps(
             {
                 "format": {
                     "version": "2.0",
@@ -721,6 +726,9 @@ BOSER_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_summary", "summary")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools", [WebAPICommand("grpc_pool_groups", "get_pool_groups")]
+        ),
     }
 )
 
@@ -790,7 +798,7 @@ class BOSer(BraiinsOSFirmware):
     async def set_power_limit(self, wattage: int) -> bool:
         try:
             result = await self.web.set_power_target(
-                wattage, save_action=SaveAction.SAVE_ACTION_SAVE_AND_FORCE_APPLY
+                wattage, save_action=SaveAction.SAVE_AND_FORCE_APPLY
             )
         except APIError:
             return False
@@ -918,8 +926,10 @@ class BOSer(BraiinsOSFirmware):
                 pass
 
         if grpc_hashboards is not None:
-            for board in grpc_hashboards["hashboards"]:
-                idx = int(board["id"]) - 1
+            grpc_boards = sorted(
+                grpc_hashboards["hashboards"], key=lambda x: int(x["id"])
+            )
+            for idx, board in enumerate(grpc_boards):
                 if board.get("chipsCount") is not None:
                     hashboards[idx].chips = board["chipsCount"]
                 if board.get("boardTemp") is not None:
@@ -943,7 +953,7 @@ class BOSer(BraiinsOSFirmware):
     async def _get_wattage(self, grpc_miner_stats: dict = None) -> Optional[int]:
         if grpc_miner_stats is None:
             try:
-                grpc_miner_stats = self.web.get_miner_stats()
+                grpc_miner_stats = await self.web.get_miner_stats()
             except APIError:
                 pass
 
@@ -975,7 +985,7 @@ class BOSer(BraiinsOSFirmware):
     async def _get_fans(self, grpc_cooling_state: dict = None) -> List[Fan]:
         if grpc_cooling_state is None:
             try:
-                grpc_cooling_state = self.web.get_cooling_state()
+                grpc_cooling_state = await self.web.get_cooling_state()
             except APIError:
                 pass
 
@@ -1064,3 +1074,27 @@ class BOSer(BraiinsOSFirmware):
                 return int(rpc_summary["SUMMARY"][0]["Elapsed"])
             except LookupError:
                 pass
+
+    async def _get_pools(self, grpc_pool_groups: dict = None) -> List[PoolMetrics]:
+        if grpc_pool_groups is None:
+            try:
+                grpc_pool_groups = await self.web.get_pool_groups()
+            except APIError:
+                return []
+        pools_data = []
+        for group in grpc_pool_groups["poolGroups"]:
+            for idx, pool_info in enumerate(group["pools"]):
+                pool_data = PoolMetrics(
+                    url=pool_info["url"],
+                    user=pool_info["user"],
+                    index=idx,
+                    accepted=pool_info["stats"].get("acceptedShares", 0),
+                    rejected=pool_info["stats"].get("rejectedShares", 0),
+                    get_failures=0,
+                    remote_failures=0,
+                    active=pool_info.get("active", False),
+                    alive=pool_info.get("alive"),
+                )
+                pools_data.append(pool_data)
+
+        return pools_data

pyasic/miners/backends/btminer.py

@@ -27,6 +27,7 @@ from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
 from pyasic.rpc.btminer import BTMinerRPCAPI
+from pyasic.data.pools import PoolMetrics, PoolUrl
 
 BTMINER_DATA_LOC = DataLocations(
     **{
@@ -109,6 +110,10 @@ BTMINER_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_summary", "summary")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        )
     }
 )
 
@@ -655,13 +660,42 @@ class BTMiner(StockFirmware):
             except LookupError:
                 pass
 
-    async def upgrade_firmware(self, file: Path, token: str):
+    async def _get_pools(self, rpc_pools: dict = None) -> List[PoolMetrics]:
+        if rpc_pools is None:
+            try:
+                rpc_pools = await self.rpc.pools()
+            except APIError:
+                pass
+
+        pools_data = []
+        if rpc_pools is not None:
+            try:
+                pools = rpc_pools.get("POOLS", [])
+                for pool_info in pools:
+                    url = pool_info.get("URL")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("Accepted"),
+                        rejected=pool_info.get("Rejected"),
+                        get_failures=pool_info.get("Get Failures"),
+                        remote_failures=pool_info.get("Remote Failures"),
+                        active=pool_info.get("Stratum Active"),
+                        alive=pool_info.get("Status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("User"),
+                        index=pool_info.get("POOL"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data
+
+    async def upgrade_firmware(self, file: Path):
         """
         Upgrade the firmware of the Whatsminer device.
 
         Args:
             file (Path): The local file path of the firmware to be uploaded.
-            token (str): The authentication token for the firmware upgrade.
 
         Returns:
             str: Confirmation message after upgrading the firmware.

pyasic/miners/backends/cgminer.py

@@ -14,7 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from typing import Optional
+from typing import Optional, List
 
 from pyasic.config import MinerConfig
 from pyasic.data import AlgoHashRate, HashUnit
@@ -22,6 +22,7 @@ from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
 from pyasic.rpc.cgminer import CGMinerRPCAPI
+from pyasic.data.pools import PoolMetrics, PoolUrl
 
 CGMINER_DATA_LOC = DataLocations(
     **{
@@ -53,6 +54,10 @@ CGMINER_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 
@@ -136,3 +141,33 @@ class CGMiner(StockFirmware):
                 return int(rpc_stats["STATS"][1]["Elapsed"])
             except LookupError:
                 pass
+
+    async def _get_pools(self, rpc_pools: dict = None) -> List[PoolMetrics]:
+        if rpc_pools is None:
+            try:
+                rpc_pools = await self.rpc.pools()
+            except APIError:
+                pass
+
+        pools_data = []
+        if rpc_pools is not None:
+            try:
+                pools = rpc_pools.get("POOLS", [])
+                for pool_info in pools:
+                    url = pool_info.get("URL")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("Accepted"),
+                        rejected=pool_info.get("Rejected"),
+                        get_failures=pool_info.get("Get Failures"),
+                        remote_failures=pool_info.get("Remote Failures"),
+                        active=pool_info.get("Stratum Active"),
+                        alive=pool_info.get("Status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("User"),
+                        index=pool_info.get("POOL"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data

pyasic/miners/backends/goldshell.py

@@ -62,6 +62,10 @@ GOLDSHELL_DATA_LOC = DataLocations(
             "_get_fans",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 

pyasic/miners/backends/iceriver.py

@@ -0,0 +1,198 @@
+from typing import List, Optional
+
+from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
+from pyasic.device import MinerAlgo
+from pyasic.errors import APIError
+from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
+from pyasic.miners.device.firmware import StockFirmware
+from pyasic.web.iceriver import IceRiverWebAPI
+
+ICERIVER_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.HOSTNAME): DataFunction(
+            "_get_hostname",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.HASHRATE): DataFunction(
+            "_get_hashrate",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.IS_MINING): DataFunction(
+            "_is_mining",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
+    }
+)
+
+
+class IceRiver(StockFirmware):
+    """Handler for IceRiver miners"""
+
+    _web_cls = IceRiverWebAPI
+    web: IceRiverWebAPI
+
+    data_locations = ICERIVER_DATA_LOC
+
+    async def fault_light_off(self) -> bool:
+        try:
+            await self.web.locate(False)
+        except APIError:
+            return False
+        return True
+
+    async def fault_light_on(self) -> bool:
+        try:
+            await self.web.locate(True)
+        except APIError:
+            return False
+        return True
+
+    async def _get_fans(self, web_userpanel: dict = None) -> List[Fan]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                return [Fan(spd) for spd in web_userpanel["fans"]]
+            except (LookupError, ValueError, TypeError):
+                pass
+
+    async def _get_mac(self, web_userpanel: dict = None) -> Optional[str]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                return web_userpanel["mac"].upper().replace("-", ":")
+            except (LookupError, ValueError, TypeError):
+                pass
+
+    async def _get_hostname(self, web_userpanel: dict = None) -> Optional[str]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                return web_userpanel["host"]
+            except (LookupError, ValueError, TypeError):
+                pass
+
+    async def _get_hashrate(self, web_userpanel: dict = None) -> Optional[AlgoHashRate]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                base_unit = web_userpanel["unit"]
+                return AlgoHashRate.SHA256(
+                    float(web_userpanel["rtpow"].replace(base_unit, "")),
+                    unit=MinerAlgo.SHA256.unit.from_str(base_unit + "H"),
+                ).into(MinerAlgo.SHA256.unit.default)
+            except (LookupError, ValueError, TypeError):
+                pass
+
+    async def _get_fault_light(self, web_userpanel: dict = None) -> bool:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                return web_userpanel["locate"]
+            except (LookupError, ValueError, TypeError):
+                pass
+        return False
+
+    async def _is_mining(self, web_userpanel: dict = None) -> Optional[bool]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                return web_userpanel["powstate"]
+            except (LookupError, ValueError, TypeError):
+                pass
+
+    async def _get_hashboards(self, web_userpanel: dict = None) -> List[HashBoard]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        hb_list = [
+            HashBoard(slot=i, expected_chips=self.expected_chips)
+            for i in range(self.expected_hashboards)
+        ]
+
+        if web_userpanel is not None:
+            try:
+                for board in web_userpanel["boards"]:
+                    idx = int(board["no"] - 1)
+                    hb_list[idx].chip_temp = round(board["outtmp"])
+                    hb_list[idx].temp = round(board["intmp"])
+                    hb_list[idx].hashrate = AlgoHashRate.SHA256(
+                        float(board["rtpow"].replace("G", "")), HashUnit.SHA256.GH
+                    ).into(self.algo.unit.default)
+                    hb_list[idx].chips = int(board["chipnum"])
+                    hb_list[idx].missing = False
+            except LookupError:
+                pass
+        return hb_list
+
+    async def _get_uptime(self, web_userpanel: dict = None) -> Optional[int]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        if web_userpanel is not None:
+            try:
+                runtime = web_userpanel["runtime"]
+                days, hours, minutes, seconds = runtime.split(":")
+                return (
+                    (int(days) * 24 * 60 * 60)
+                    + (int(hours) * 60 * 60)
+                    + (int(minutes) * 60)
+                    + int(seconds)
+                )
+            except (LookupError, ValueError, TypeError):
+                pass

pyasic/miners/backends/luxminer.py

@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from typing import List, Optional
+import logging
 
 from pyasic.config import MinerConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
@@ -146,6 +147,22 @@ class LUXMiner(LuxOSFirmware):
     async def get_config(self) -> MinerConfig:
         return self.config
 
+    async def upgrade_firmware(self) -> bool:
+        """
+        Upgrade the firmware on a LuxOS miner by calling the 'updaterun' API command.
+        Returns:
+            bool: True if the firmware upgrade was successfully initiated, False otherwise.
+        """
+        try:
+            await self.rpc.upgraderun()
+            logging.info(f"{self.ip}: Firmware upgrade initiated successfully.")
+            return True
+
+        except APIError as e:
+            logging.error(f"{self.ip}: Firmware upgrade failed: {e}")
+
+        return False
+
     ##################################################
     ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
     ##################################################

pyasic/miners/backends/marathon.py

@@ -7,7 +7,9 @@ from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
 from pyasic.miners.device.firmware import MaraFirmware
 from pyasic.misc import merge_dicts
+from pyasic.rpc.marathon import MaraRPCAPI
 from pyasic.web.marathon import MaraWebAPI
+from pyasic.data.pools import PoolMetrics, PoolUrl
 
 MARA_DATA_LOC = DataLocations(
     **{
@@ -59,11 +61,17 @@ MARA_DATA_LOC = DataLocations(
             "_get_uptime",
             [WebAPICommand("web_brief", "brief")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [WebAPICommand("web_pools", "pools")],
+        ),
     }
 )
 
 
 class MaraMiner(MaraFirmware):
+    _rpc_cls = MaraRPCAPI
+    rpc: MaraRPCAPI
     _web_cls = MaraWebAPI
     web: MaraWebAPI
 
@@ -302,3 +310,40 @@ class MaraMiner(MaraFirmware):
                 return web_miner_config["mode"]["concorde"]["power-target"]
             except LookupError:
                 pass
+
+    async def _get_pools(self, web_pools: list = None) -> List[PoolMetrics]:
+        if web_pools is None:
+            try:
+                web_pools = await self.web.pools()
+            except APIError:
+                return []
+
+        active_pool_index = None
+        highest_priority = float('inf')
+
+        for pool_info in web_pools:
+            if pool_info.get("status") == "Alive" and pool_info.get("priority", float('inf')) < highest_priority:
+                highest_priority = pool_info.get["priority"]
+                active_pool_index = pool_info["index"]
+
+        pools_data = []
+        if web_pools is not None:
+            try:
+                for pool_info in web_pools:
+                    url = pool_info.get("url")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("accepted"),
+                        rejected=pool_info.get("rejected"),
+                        get_failures=pool_info.get("stale"),
+                        remote_failures=pool_info.get("discarded"),
+                        active=pool_info.get("index") == active_pool_index,
+                        alive=pool_info.get("status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("user"),
+                        index=pool_info.get("index"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data

pyasic/miners/base.py

@@ -560,5 +560,18 @@ class BaseMiner(MinerProtocol):
         if self._ssh_cls is not None:
             self.ssh = self._ssh_cls(ip)
 
+    async def upgrade_firmware(self, *, file: str = None, url: str = None, version: str = None, keep_settings: bool = True) -> bool:
+        """Upgrade the firmware of the miner.
+
+        Parameters:
+            file (str, optional): The file path to the firmware to upgrade from. Must be a valid file path if provided.
+            url (str, optional): The URL to download the firmware from. Must be a valid URL if provided.
+            version (str, optional): The version of the firmware to upgrade to. If None, the version will be inferred from the file or URL.
+            keep_settings (bool, optional): Whether to keep the current settings during the upgrade. Defaults to True.
+
+        Returns:
+            A boolean value of the success of the firmware upgrade.
+        """
+        return False
 
 AnyMiner = TypeVar("AnyMiner", bound=BaseMiner)

pyasic/miners/device/firmware.py

@@ -43,4 +43,4 @@ class LuxOSFirmware(BaseMiner):
 
 
 class MaraFirmware(BaseMiner):
-    firmware = MinerFirmware.MARATHON
+    firmware = MinerFirmware.MARATHON

pyasic/miners/device/makes.py

@@ -48,3 +48,7 @@ class ePICMake(BaseMiner):
 
 class BitAxeMake(BaseMiner):
     make = MinerMake.BITAXE
+
+
+class IceRiverMake(BaseMiner):
+    make = MinerMake.ICERIVER

pyasic/miners/device/models/__init__.py

@@ -19,5 +19,6 @@ from .auradine import *
 from .avalonminer import *
 from .epic import *
 from .goldshell import *
+from .iceriver import *
 from .innosilicon import *
 from .whatsminer import *

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

@@ -22,3 +22,10 @@ class S21(AntMinerMake):
 
     expected_chips = 108
     expected_fans = 4
+
+
+class S21Pro(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S21Pro
+
+    expected_chips = 65
+    expected_fans = 4

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

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

pyasic/miners/device/models/antminer/X3/KA3.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class KA3(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.KA3
+
+    expected_chips = 92

pyasic/miners/device/models/antminer/X3/KS3.py

@@ -0,0 +1,24 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class KS3(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.KS3
+
+    expected_chips = 92
+    expected_fans = 2

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

@@ -15,4 +15,6 @@
 # ------------------------------------------------------------------------------
 from .D3 import D3
 from .HS3 import HS3
+from .KA3 import KA3
+from .KS3 import KS3
 from .L3 import L3Plus

pyasic/miners/device/models/antminer/X5/KS5.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class KS5(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.KS5
+
+    expected_chips = 92

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

@@ -14,3 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from .DR5 import DR5
+from .KS5 import KS5

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

@@ -20,3 +20,4 @@ from .A9X import *
 from .A10X import *
 from .A11X import *
 from .A12X import *
+from .nano import *

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

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

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

@@ -0,0 +1,10 @@
+from pyasic.device import MinerModel
+from pyasic.miners.device.makes import AvalonMinerMake
+
+
+class AvalonNano3(AvalonMinerMake):
+    raw_model = MinerModel.AVALONMINER.AvalonNano3
+
+    expected_hashboards = 1
+    expected_chips = 10
+    expected_fans = 1

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

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS0(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS0
+
+    expected_fans = 0

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

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS1(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS1
+
+    expected_fans = 4

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

@@ -0,0 +1,24 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS2(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS2
+
+    expected_fans = 4
+    expected_chips = 18

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

@@ -0,0 +1,36 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS3(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS3
+
+    expected_fans = 4
+
+
+class KS3L(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS3L
+
+    expected_fans = 4
+
+
+class KS3M(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS3M
+
+    expected_fans = 4
+    expected_chips = 18

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

@@ -0,0 +1,4 @@
+from .KS0 import KS0
+from .KS1 import KS1
+from .KS2 import KS2
+from .KS3 import KS3, KS3L, KS3M

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

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

pyasic/miners/device/models/innosilicon/A11X/A11M.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  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.models import MinerModel
+from pyasic.miners.device.makes import InnosiliconMake
+
+
+class A11MX(InnosiliconMake):
+    raw_model = MinerModel.INNOSILICON.A11MX
+
+    expected_hashboards = 4

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

@@ -0,0 +1,16 @@
+# ------------------------------------------------------------------------------
+#  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 .A11M import *

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

@@ -15,4 +15,5 @@
 # ------------------------------------------------------------------------------
 
 from .A10X import *
+from .A11X import *
 from .T3X import *

pyasic/miners/device/models/whatsminer/M5X/M50.py

@@ -69,6 +69,8 @@ class M50VH60(WhatsMinerMake):
 class M50VH70(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VH70
 
+    expected_chips = 105
+
 
 class M50VH80(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VH80
@@ -83,6 +85,10 @@ class M50VJ10(WhatsMinerMake):
 class M50VJ20(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VJ20
 
+    expected_chips = 111
+
 
 class M50VJ30(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VJ30
+
+    expected_chips = 117

pyasic/miners/device/models/whatsminer/M5X/M50S.py

@@ -51,3 +51,5 @@ class M50SVH40(WhatsMinerMake):
 
 class M50SVH50(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50SVH50
+
+    expected_chips = 135

pyasic/miners/device/models/whatsminer/M6X/M60.py

@@ -24,6 +24,8 @@ class M60VK10(WhatsMinerMake):
 class M60VK20(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M60VK20
 
+    expected_chips = 172
+
 
 class M60VK30(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M60VK30

pyasic/miners/factory.py

@@ -20,6 +20,7 @@ import enum
 import ipaddress
 import json
 import re
+import warnings
 from typing import Any, AsyncGenerator, Callable
 
 import anyio
@@ -38,6 +39,7 @@ from pyasic.miners.bitaxe import *
 from pyasic.miners.blockminer import *
 from pyasic.miners.device.makes import *
 from pyasic.miners.goldshell import *
+from pyasic.miners.iceriver import *
 from pyasic.miners.innosilicon import *
 from pyasic.miners.whatsminer import *
 
@@ -56,6 +58,7 @@ class MinerTypes(enum.Enum):
     AURADINE = 10
     MARATHON = 11
     BITAXE = 12
+    ICERIVER = 13
 
 
 MINER_CLASSES = {
@@ -64,7 +67,10 @@ MINER_CLASSES = {
         "ANTMINER D3": CGMinerD3,
         "ANTMINER HS3": BMMinerHS3,
         "ANTMINER L3+": BMMinerL3Plus,
+        "ANTMINER KA3": BMMinerKA3,
+        "ANTMINER KS3": BMMinerKS3,
         "ANTMINER DR5": CGMinerDR5,
+        "ANTMINER KS5": BMMinerKS5,
         "ANTMINER L7": BMMinerL7,
         "ANTMINER E9 PRO": BMMinerE9Pro,
         "ANTMINER S9": BMMinerS9,
@@ -97,6 +103,7 @@ MINER_CLASSES = {
         "ANTMINER S19K PRO": BMMinerS19KPro,
         "ANTMINER T19": BMMinerT19,
         "ANTMINER S21": BMMinerS21,
+        "ANTMINER S21 PRO": BMMinerS21Pro,
         "ANTMINER T21": BMMinerT21,
     },
     MinerTypes.WHATSMINER: {
@@ -329,11 +336,13 @@ MINER_CLASSES = {
         "AVALONMINER 1066": CGMinerAvalon1066,
         "AVALONMINER 1166PRO": CGMinerAvalon1166Pro,
         "AVALONMINER 1246": CGMinerAvalon1246,
+        "AVALONMINER NANO3": CGMinerAvalonNano3,
     },
     MinerTypes.INNOSILICON: {
         None: type("InnosiliconUnknown", (Innosilicon, InnosiliconMake), {}),
         "T3H+": InnosiliconT3HPlus,
         "A10X": InnosiliconA10X,
+        "A11MX": InnosiliconA11MX,
     },
     MinerTypes.GOLDSHELL: {
         None: type("GoldshellUnknown", (GoldshellMiner, GoldshellMake), {}),
@@ -372,6 +381,7 @@ MINER_CLASSES = {
         "ANTMINER S19 PRO+ HYD.": BOSMinerS19ProPlusHydro,
         "ANTMINER T19": BOSMinerT19,
         "ANTMINER S21": BOSMinerS21,
+        "ANTMINER T21": BOSMinerT21,
     },
     MinerTypes.VNISH: {
         None: VNish,
@@ -401,6 +411,7 @@ MINER_CLASSES = {
         "ANTMINER S19K PRO": ePICS19kPro,
         "ANTMINER S19 XP": ePICS19XP,
         "ANTMINER S21": ePICS21,
+        "ANTMINER S21 PRO": ePICS21Pro,
         "ANTMINER T21": ePICT21,
         "BLOCKMINER 520I": ePICBlockMiner520i,
         "BLOCKMINER 720I": ePICBlockMiner720i,
@@ -449,6 +460,15 @@ MINER_CLASSES = {
         "BM1366": BitAxeUltra,
         "BM1397": BitAxeMax,
     },
+    MinerTypes.ICERIVER: {
+        None: type("IceRiverUnknown", (IceRiver, IceRiverMake), {}),
+        "KS0": IceRiverKS0,
+        "KS1": IceRiverKS1,
+        "KS2": IceRiverKS2,
+        "KS3": IceRiverKS3,
+        "KS3L": IceRiverKS3L,
+        "KS3M": IceRiverKS3M,
+    },
 }
 
 
@@ -607,6 +627,8 @@ class MinerFactory:
                 return MinerTypes.WHATSMINER
         if "Braiins OS" in web_text:
             return MinerTypes.BRAIINS_OS
+        if "<TITLE>用户界面</TITLE>" in web_text:
+            return MinerTypes.ICERIVER
         if "AxeOS" in web_text:
             return MinerTypes.BITAXE
         if "cloud-box" in web_text:
@@ -687,8 +709,6 @@ class MinerFactory:
             return MinerTypes.BRAIINS_OS
         if "BTMINER" in upper_data or "BITMICRO" in upper_data:
             return MinerTypes.WHATSMINER
-        if "VNISH" in upper_data or "DEVICE PATH" in upper_data:
-            return MinerTypes.VNISH
         if "HIVEON" in upper_data:
             return MinerTypes.HIVEON
         if "LUXMINER" in upper_data:
@@ -703,10 +723,14 @@ class MinerFactory:
             or "BFGMINER" in upper_data
         ):
             return MinerTypes.GOLDSHELL
+        if "INNOMINER" in upper_data:
+            return MinerTypes.INNOSILICON
         if "AVALON" in upper_data:
             return MinerTypes.AVALONMINER
         if "GCMINER" in upper_data or "FLUXOS" in upper_data:
             return MinerTypes.AURADINE
+        if "VNISH" in upper_data:
+            return MinerTypes.VNISH
 
     async def send_web_command(
         self,
@@ -796,7 +820,9 @@ class MinerFactory:
         str_data = str_data.replace("info", "1nfo")
         str_data = str_data.replace("inf", "0")
         str_data = str_data.replace("1nfo", "info")
+        str_data = str_data.replace("nano", "n4no")
         str_data = str_data.replace("nan", "0")
+        str_data = str_data.replace("n4no", "nano")
         # fix whatever this garbage from avalonminers is `,"id":1}`
         if str_data.startswith(","):
             str_data = f"{{{str_data[1:]}"
@@ -821,6 +847,10 @@ class MinerFactory:
             return MINER_CLASSES[miner_type][str(miner_model).upper()](ip)
         except LookupError:
             if miner_type in MINER_CLASSES:
+                warnings.warn(
+                    f"Partially supported miner found: {miner_model}, 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)
             return UnknownMiner(str(ip))
 
@@ -896,10 +926,12 @@ class MinerFactory:
     async def get_miner_model_avalonminer(self, ip: str) -> str | None:
         sock_json_data = await self.send_api_command(ip, "version")
         try:
-            miner_model = sock_json_data["VERSION"][0]["PROD"]
+            miner_model = sock_json_data["VERSION"][0]["PROD"].upper()
             if "-" in miner_model:
                 miner_model = miner_model.split("-")[0]
-
+            if miner_model in ["AVALONNANO", "AVALON0O"]:
+                nano_subtype = sock_json_data["VERSION"][0]["MODEL"].upper()
+                miner_model = f"AVALONMINER {nano_subtype}"
             return miner_model
         except (TypeError, LookupError):
             pass
@@ -909,10 +941,19 @@ class MinerFactory:
             async with httpx.AsyncClient(transport=settings.transport()) as session:
                 auth_req = await session.post(
                     f"http://{ip}/api/auth",
-                    data={"username": "admin", "password": "admin"},
+                    data={
+                        "username": "admin",
+                        "password": settings.get(
+                            "default_innosilicon_web_password", "admin"
+                        ),
+                    },
                 )
                 auth = auth_req.json()["jwt"]
+        except (httpx.HTTPError, LookupError):
+            return
 
+        try:
+            async with httpx.AsyncClient(transport=settings.transport()) as session:
                 web_data = (
                     await session.post(
                         f"http://{ip}/api/type",
@@ -923,6 +964,18 @@ class MinerFactory:
                 return web_data["type"]
         except (httpx.HTTPError, LookupError):
             pass
+        try:
+            async with httpx.AsyncClient(transport=settings.transport()) as session:
+                web_data = (
+                    await session.post(
+                        f"http://{ip}/overview",
+                        headers={"Authorization": "Bearer " + auth},
+                        data={},
+                    )
+                ).json()
+                return web_data["type"]
+        except (httpx.HTTPError, LookupError):
+            pass
 
     async def get_miner_model_braiins_os(self, ip: str) -> str | None:
         sock_json_data = await self.send_api_command(ip, "devdetails")
@@ -1036,6 +1089,39 @@ class MinerFactory:
         except (TypeError, LookupError):
             pass
 
+    async def get_miner_model_iceriver(self, ip: str) -> str | None:
+        async with httpx.AsyncClient(transport=settings.transport()) as client:
+            try:
+                # auth
+                await client.post(
+                    f"http://{ip}/user/loginpost",
+                    params={
+                        "post": "6",
+                        "user": "admin",
+                        "pwd": settings.get(
+                            "default_iceriver_web_password", "12345678"
+                        ),
+                    },
+                )
+            except httpx.HTTPError:
+                return None
+            try:
+                resp = await client.post(
+                    f"http://{ip}:/user/userpanel", params={"post": "4"}
+                )
+                if not resp.status_code == 200:
+                    return
+                result = resp.json()
+                software_ver = result["data"]["softver1"]
+                split_ver = software_ver.split("_")
+                if split_ver[-1] == "miner":
+                    miner_ver = split_ver[-2]
+                else:
+                    miner_ver = split_ver[-1].replace("miner", "")
+                return miner_ver.upper()
+            except httpx.HTTPError:
+                pass
+
 
 miner_factory = MinerFactory()
 

pyasic/miners/iceriver/__init__.py

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

pyasic/miners/iceriver/iceminer/KSX/KS0.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models import KS0
+
+
+class IceRiverKS0(IceRiver, KS0):
+    pass

pyasic/miners/iceriver/iceminer/KSX/KS1.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models import KS1
+
+
+class IceRiverKS1(IceRiver, KS1):
+    pass

pyasic/miners/iceriver/iceminer/KSX/KS2.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models import KS2
+
+
+class IceRiverKS2(IceRiver, KS2):
+    pass

pyasic/miners/iceriver/iceminer/KSX/KS3.py

@@ -0,0 +1,14 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models.iceriver import KS3, KS3L, KS3M
+
+
+class IceRiverKS3(IceRiver, KS3):
+    pass
+
+
+class IceRiverKS3L(IceRiver, KS3L):
+    pass
+
+
+class IceRiverKS3M(IceRiver, KS3M):
+    pass

pyasic/miners/iceriver/iceminer/KSX/__init__.py

@@ -0,0 +1,4 @@
+from .KS0 import IceRiverKS0
+from .KS1 import IceRiverKS1
+from .KS2 import IceRiverKS2
+from .KS3 import IceRiverKS3, IceRiverKS3L, IceRiverKS3M

pyasic/miners/iceriver/iceminer/__init__.py

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

pyasic/miners/innosilicon/cgminer/A11X/A11M.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.innosilicon import Innosilicon
+from pyasic.miners.device.models import A11MX
+
+
+class InnosiliconA11MX(Innosilicon, A11MX):
+    pass

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

@@ -0,0 +1 @@
+from .A11M import InnosiliconA11MX

pyasic/miners/innosilicon/cgminer/__init__.py

@@ -15,4 +15,5 @@
 # ------------------------------------------------------------------------------
 
 from .A10X import *
+from .A11X import *
 from .T3X import *

pyasic/network/__init__.py

@@ -144,12 +144,9 @@ class MinerNetwork:
         Returns:
              An asynchronous generator containing found miners.
         """
-        # get the current event loop
-        loop = asyncio.get_event_loop()
-
         # create a list of scan tasks
         miners = asyncio.as_completed(
-            [loop.create_task(self.ping_and_get_miner(host)) for host in self.hosts]
+            [asyncio.create_task(self.ping_and_get_miner(host)) for host in self.hosts]
         )
         for miner in miners:
             try:

pyasic/rpc/base.py

@@ -215,14 +215,18 @@ If you are sure you want to use this command please use API.send_command("{comma
             return b"{}"
 
         # send the command
-        data_task = asyncio.create_task(self._read_bytes(reader, timeout=timeout))
-        logging.debug(f"{self} - ([Hidden] Send Bytes) - Writing")
-        writer.write(data)
-        logging.debug(f"{self} - ([Hidden] Send Bytes) - Draining")
-        await writer.drain()
+        try:
+            data_task = asyncio.create_task(self._read_bytes(reader, timeout=timeout))
+            logging.debug(f"{self} - ([Hidden] Send Bytes) - Writing")
+            writer.write(data)
+            logging.debug(f"{self} - ([Hidden] Send Bytes) - Draining")
+            await writer.drain()
 
-        await data_task
-        ret_data = data_task.result()
+            await data_task
+            ret_data = data_task.result()
+        except TimeoutError:
+            logging.warning(f"{self} - ([Hidden] Send Bytes) - Read timeout expired.")
+            return b"{}"
 
         # close the connection
         logging.debug(f"{self} - ([Hidden] Send Bytes) - Closing")
@@ -264,10 +268,9 @@ If you are sure you want to use this command please use API.send_command("{comma
         # fix an error with a btminer return having a missing comma. (2023-01-06 version)
         str_data = str_data.replace('""temp0', '","temp0')
         # fix an error with Avalonminers returning inf and nan
-        str_data = str_data.replace("info", "1nfo")
-        str_data = str_data.replace("inf", "0")
-        str_data = str_data.replace("1nfo", "info")
-        str_data = str_data.replace("nan", "0")
+        str_data = str_data.replace('"inf"', "0")
+        str_data = str_data.replace('"nan"', "0")
+
         # fix whatever this garbage from avalonminers is `,"id":1}`
         if str_data.startswith(","):
             str_data = f"{{{str_data[1:]}"

pyasic/rpc/luxminer.py

@@ -749,3 +749,12 @@ class LUXMinerRPCAPI(BaseMinerRPCAPI):
         </details>
         """
         return await self.send_command("wakeup", parameters=session_id)
+
+    async def upgraderun(self):
+        """
+        Send the 'updaterun' command to the miner.
+
+        Returns:
+            The response from the miner after sending the 'updaterun' command.
+        """
+        return await self.send_command("updaterun")

pyasic/rpc/marathon.py

@@ -0,0 +1,33 @@
+from pyasic.rpc.base import BaseMinerRPCAPI
+
+
+class MaraRPCAPI(BaseMinerRPCAPI):
+    """An abstraction of the MaraFW API.
+
+    Each method corresponds to an API command in MaraFW.
+
+    No documentation for this API is currently publicly available.
+
+    Additionally, every command not included here just returns the result of the `summary` command.
+
+    This class abstracts use of the MaraFW API, as well as the
+    methods for sending commands to it.  The `self.send_command()`
+    function handles sending a command to the miner asynchronously, and
+    as such is the base for many of the functions in this class, which
+    rely on it to send the command for them.
+    """
+
+    async def summary(self):
+        return await self.send_command("summary")
+
+    async def devs(self):
+        return await self.send_command("devs")
+
+    async def pools(self):
+        return await self.send_command("pools")
+
+    async def stats(self):
+        return await self.send_command("stats")
+
+    async def version(self):
+        return await self.send_command("version")

pyasic/settings/__init__.py

@@ -13,8 +13,6 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-import socket
-import struct
 from ssl import SSLContext
 from typing import Any, Union
 
@@ -39,25 +37,19 @@ _settings = {  # defaults
     "default_auradine_web_password": "admin",
     "default_epic_web_password": "letmein",
     "default_hive_web_password": "admin",
+    "default_iceriver_web_password": "12345678",
     "default_antminer_ssh_password": "miner",
     "default_bosminer_ssh_password": "root",
-    "socket_linger_time": 1000,
 }
 
 
 ssl_cxt = httpx.create_ssl_context()
 
 
-# this function configures socket options like SO_LINGER and returns an AsyncHTTPTransport instance to perform asynchronous HTTP requests
+# this function returns an AsyncHTTPTransport instance to perform asynchronous HTTP requests
 # using those options.
-# SO_LINGER controls what happens when you close a socket with unsent data - it allows specifying linger time for the data to be sent.
 def transport(verify: Union[str, bool, SSLContext] = ssl_cxt):
-    l_onoff = 1
-    l_linger = get("so_linger_time", 1000)
-
-    opts = [(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", l_onoff, l_linger))]
-
-    return AsyncHTTPTransport(socket_options=opts, verify=verify)
+    return AsyncHTTPTransport(verify=verify)
 
 
 def get(key: str, other: Any = None) -> Any:

pyasic/web/__init__.py

@@ -19,5 +19,6 @@ from .base import BaseWebAPI
 from .braiins_os import BOSerWebAPI, BOSMinerWebAPI
 from .epic import ePICWebAPI
 from .goldshell import GoldshellWebAPI
+from .iceriver import IceRiverWebAPI
 from .innosilicon import InnosiliconWebAPI
 from .vnish import VNishWebAPI

pyasic/web/antminer.py

@@ -18,8 +18,9 @@ from __future__ import annotations
 import asyncio
 import json
 from typing import Any
-
+import aiofiles
 import httpx
+from pathlib import Path
 
 from pyasic import settings
 from pyasic.web.base import BaseWebAPI
@@ -59,9 +60,8 @@ class AntminerModernWebAPI(BaseWebAPI):
         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:
+            async with httpx.AsyncClient(transport=settings.transport()) as client:
+
                 if parameters:
                     data = await client.post(
                         url,
@@ -71,14 +71,15 @@ class AntminerModernWebAPI(BaseWebAPI):
                     )
                 else:
                     data = await client.get(url, auth=auth)
-        except httpx.HTTPError:
-            pass
+        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:
-                    pass
+                    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
@@ -403,3 +404,20 @@ class AntminerOldWebAPI(BaseWebAPI):
             dict: Information about the mining pools configured in the miner.
         """
         return await self.send_command("miner_pools")
+
+    async def update_firmware(self, file: Path, keep_settings: bool = True) -> dict:
+        """Perform a system update by uploading a firmware file and sending a command to initiate the update."""
+
+        async with aiofiles.open(file, "rb") as firmware:
+            file_content = await firmware.read()
+
+        parameters = {
+            "file": (file.name, file_content, "application/octet-stream"),
+            "filename": file.name,
+            "keep_settings": keep_settings
+        }
+
+        return await self.send_command(
+            command="upgrade",
+            **parameters
+        )

pyasic/web/braiins_os/better_monkey.py

@@ -0,0 +1,93 @@
+from datetime import datetime, timedelta
+from typing import Any, Dict
+
+from betterproto import DATETIME_ZERO, TYPE_MAP, TYPE_MESSAGE, Casing, Message
+
+
+# https://github.com/danielgtaylor/python-betterproto/pull/609
+def to_pydict(
+    self, casing: Casing = Casing.CAMEL, include_default_values: bool = False
+) -> Dict[str, Any]:
+    """
+    Returns a python dict representation of this object.
+
+    Parameters
+    -----------
+    casing: :class:`Casing`
+        The casing to use for key values. Default is :attr:`Casing.CAMEL` for
+        compatibility purposes.
+    include_default_values: :class:`bool`
+        If ``True`` will include the default values of fields. Default is ``False``.
+        E.g. an ``int32`` field will be included with a value of ``0`` if this is
+        set to ``True``, otherwise this would be ignored.
+
+    Returns
+    --------
+    Dict[:class:`str`, Any]
+        The python dict representation of this object.
+    """
+    output: Dict[str, Any] = {}
+    defaults = self._betterproto.default_gen
+    for field_name, meta in self._betterproto.meta_by_field_name.items():
+        field_is_repeated = defaults[field_name] is list
+        try:
+            value = getattr(self, field_name)
+        except AttributeError:
+            value = self._get_field_default(field_name)
+        cased_name = casing(field_name).rstrip("_")  # type: ignore
+        if meta.proto_type == TYPE_MESSAGE:
+            if isinstance(value, datetime):
+                if (
+                    value != DATETIME_ZERO
+                    or include_default_values
+                    or self._include_default_value_for_oneof(
+                        field_name=field_name, meta=meta
+                    )
+                ):
+                    output[cased_name] = value
+            elif isinstance(value, timedelta):
+                if (
+                    value != timedelta(0)
+                    or include_default_values
+                    or self._include_default_value_for_oneof(
+                        field_name=field_name, meta=meta
+                    )
+                ):
+                    output[cased_name] = value
+            elif meta.wraps:
+                if value is not None or include_default_values:
+                    output[cased_name] = value
+            elif field_is_repeated:
+                # Convert each item.
+                value = [i.to_pydict(casing, include_default_values) for i in value]
+                if value or include_default_values:
+                    output[cased_name] = value
+            elif value is None:
+                if include_default_values:
+                    output[cased_name] = None
+            elif (
+                value._serialized_on_wire
+                or include_default_values
+                or self._include_default_value_for_oneof(
+                    field_name=field_name, meta=meta
+                )
+            ):
+                output[cased_name] = value.to_pydict(casing, include_default_values)
+        elif meta.proto_type == TYPE_MAP:
+            for k in value:
+                if hasattr(value[k], "to_pydict"):
+                    value[k] = value[k].to_pydict(casing, include_default_values)
+
+            if value or include_default_values:
+                output[cased_name] = value
+        elif (
+            value != self._get_field_default(field_name)
+            or include_default_values
+            or self._include_default_value_for_oneof(field_name=field_name, meta=meta)
+        ):
+            output[cased_name] = value
+    return output
+
+
+def patch():
+    Message.to_pydict = to_pydict

pyasic/web/braiins_os/boser.py

@@ -26,6 +26,9 @@ from grpclib.client import Channel
 from pyasic import settings
 from pyasic.errors import APIError
 from pyasic.web.base import BaseWebAPI
+from pyasic.web.braiins_os.better_monkey import patch
+
+patch()
 
 from .proto.braiins.bos import *
 from .proto.braiins.bos.v1 import *
@@ -206,7 +209,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def set_immersion_mode(
         self,
         enable: bool,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "set_immersion_mode",
@@ -227,7 +230,7 @@ class BOSerWebAPI(BaseWebAPI):
         )
 
     async def set_default_power_target(
-        self, save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY
+        self, save_action: SaveAction = SaveAction.SAVE_AND_APPLY
     ) -> dict:
         return await self.send_command(
             "set_default_power_target",
@@ -238,7 +241,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def set_power_target(
         self,
         power_target: int,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "set_power_target",
@@ -251,7 +254,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def increment_power_target(
         self,
         power_target_increment: int,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "increment_power_target",
@@ -265,7 +268,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def decrement_power_target(
         self,
         power_target_decrement: int,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "decrement_power_target",
@@ -277,7 +280,7 @@ class BOSerWebAPI(BaseWebAPI):
         )
 
     async def set_default_hashrate_target(
-        self, save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY
+        self, save_action: SaveAction = SaveAction.SAVE_AND_APPLY
     ) -> dict:
         return await self.send_command(
             "set_default_hashrate_target",
@@ -288,7 +291,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def set_hashrate_target(
         self,
         hashrate_target: float,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "set_hashrate_target",
@@ -302,7 +305,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def increment_hashrate_target(
         self,
         hashrate_target_increment: int,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "increment_hashrate_target",
@@ -318,7 +321,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def decrement_hashrate_target(
         self,
         hashrate_target_decrement: int,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "decrement_hashrate_target",
@@ -359,7 +362,7 @@ class BOSerWebAPI(BaseWebAPI):
         self,
         wattage_target: int = None,
         hashrate_target: int = None,
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         if wattage_target is not None and hashrate_target is not None:
             logging.error(
@@ -459,7 +462,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def enable_hashboards(
         self,
         hashboard_ids: List[str],
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "enable_hashboards",
@@ -472,7 +475,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def disable_hashboards(
         self,
         hashboard_ids: List[str],
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "disable_hashboards",
@@ -485,7 +488,7 @@ class BOSerWebAPI(BaseWebAPI):
     async def set_pool_groups(
         self,
         pool_groups: List[PoolGroupConfiguration],
-        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+        save_action: SaveAction = SaveAction.SAVE_AND_APPLY,
     ) -> dict:
         return await self.send_command(
             "set_pool_groups",

pyasic/web/braiins_os/proto/braiins/bos/__init__.py

@@ -4,12 +4,17 @@
 # This file has been @generated
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Optional,
+)
 
 import betterproto
 import grpclib
 from betterproto.grpc.grpclib_server import ServiceBase
 
+
 if TYPE_CHECKING:
     import grpclib.server
     from betterproto.grpc.grpclib_client import MetadataLike
@@ -18,7 +23,7 @@ if TYPE_CHECKING:
 
 @dataclass(eq=False, repr=False)
 class ApiVersion(betterproto.Message):
-    """LATEST_API_VERSION=1.2.0"""
+    """LATEST_API_VERSION=1.3.0"""
 
     major: int = betterproto.uint64_field(1)
     minor: int = betterproto.uint64_field(2)

pyasic/web/braiins_os/proto/braiins/bos/v1/__init__.py

@@ -5,12 +5,19 @@
 import warnings
 from dataclasses import dataclass
 from datetime import datetime
-from typing import TYPE_CHECKING, AsyncIterator, Dict, List, Optional
+from typing import (
+    TYPE_CHECKING,
+    AsyncIterator,
+    Dict,
+    List,
+    Optional,
+)
 
 import betterproto
 import grpclib
 from betterproto.grpc.grpclib_server import ServiceBase
 
+
 if TYPE_CHECKING:
     import grpclib.server
     from betterproto.grpc.grpclib_client import MetadataLike
@@ -20,125 +27,129 @@ if TYPE_CHECKING:
 class SaveAction(betterproto.Enum):
     """Save action for different operations"""
 
-    SAVE_ACTION_UNSPECIFIED = 0
-    SAVE_ACTION_SAVE = 1
-    SAVE_ACTION_SAVE_AND_APPLY = 2
-    SAVE_ACTION_SAVE_AND_FORCE_APPLY = 3
+    UNSPECIFIED = 0
+    SAVE = 1
+    SAVE_AND_APPLY = 2
+    SAVE_AND_FORCE_APPLY = 3
 
 
 class CoolingMode(betterproto.Enum):
-    COOLING_MODE_UNSPECIFIED = 0
-    COOLING_MODE_AUTO = 1
-    COOLING_MODE_MANUAL = 2
-    COOLING_MODE_DISABLED = 3
+    UNSPECIFIED = 0
+    AUTO = 1
+    MANUAL = 2
+    DISABLED = 3
 
 
 class SensorLocation(betterproto.Enum):
-    SENSOR_LOCATION_UNSPECIFIED = 0
-    SENSOR_LOCATION_CHIP = 1
-    SENSOR_LOCATION_PCB = 2
+    UNSPECIFIED = 0
+    CHIP = 1
+    PCB = 2
 
 
 class TunerMode(betterproto.Enum):
-    TUNER_MODE_UNSPECIFIED = 0
-    TUNER_MODE_POWER_TARGET = 1
-    TUNER_MODE_HASHRATE_TARGET = 2
+    UNSPECIFIED = 0
+    POWER_TARGET = 1
+    HASHRATE_TARGET = 2
 
 
 class TunerState(betterproto.Enum):
-    TUNER_STATE_UNSPECIFIED = 0
-    TUNER_STATE_DISABLED = 1
-    TUNER_STATE_STABLE = 2
-    TUNER_STATE_TUNING = 3
-    TUNER_STATE_ERROR = 4
+    UNSPECIFIED = 0
+    DISABLED = 1
+    STABLE = 2
+    TUNING = 3
+    ERROR = 4
 
 
 class LicenseType(betterproto.Enum):
-    LICENSE_TYPE_UNSPECIFIED = 0
-    LICENSE_TYPE_STANDARD = 1
-    LICENSE_TYPE_CUSTOM = 2
+    UNSPECIFIED = 0
+    STANDARD = 1
+    CUSTOM = 2
 
 
 class Platform(betterproto.Enum):
     """Supported platforms"""
 
-    PLATFORM_UNSPECIFIED = 0
-    PLATFORM_AM1_S9 = 1
-    PLATFORM_AM2_S17 = 2
-    PLATFORM_AM3_BBB = 3
-    PLATFORM_AM3_AML = 4
-    PLATFORM_STM32MP157C_II1_AM2 = 5
-    PLATFORM_CVITEK_BM1_AM2 = 6
-    PLATFORM_ZYNQ_BM3_AM2 = 7
+    UNSPECIFIED = 0
+    AM1_S9 = 1
+    AM2_S17 = 2
+    AM3_BBB = 3
+    AM3_AML = 4
+    STM32MP157C_II1_AM2 = 5
+    CVITEK_BM1_AM2 = 6
+    ZYNQ_BM3_AM2 = 7
+    STM32MP157C_II2_BMM1 = 8
 
 
 class BosMode(betterproto.Enum):
     """BOS modes enumeration"""
 
-    BOS_MODE_UNSPECIFIED = 0
-    BOS_MODE_UPGRADE = 1
-    BOS_MODE_RECOVERY = 2
-    BOS_MODE_SD = 3
-    BOS_MODE_NAND = 4
-    BOS_MODE_EMMC = 5
+    UNSPECIFIED = 0
+    UPGRADE = 1
+    RECOVERY = 2
+    SD = 3
+    NAND = 4
+    EMMC = 5
 
 
 class MinerBrand(betterproto.Enum):
-    MINER_BRAND_UNSPECIFIED = 0
-    MINER_BRAND_ANTMINER = 1
-    MINER_BRAND_WHATSMINER = 2
+    UNSPECIFIED = 0
+    ANTMINER = 1
+    WHATSMINER = 2
 
 
 class MinerModel(betterproto.Enum):
     """Deprecated: This enumeration is not longer maintained"""
 
-    MINER_MODEL_UNSPECIFIED = 0
-    MINER_MODEL_ANTMINER_S9 = 1
-    MINER_MODEL_ANTMINER_X17 = 2
-    MINER_MODEL_ANTMINER_S17 = 3
-    MINER_MODEL_ANTMINER_S17_PLUS = 4
-    MINER_MODEL_ANTMINER_S17_PRO = 5
-    MINER_MODEL_ANTMINER_S17E = 6
-    MINER_MODEL_ANTMINER_T17 = 7
-    MINER_MODEL_ANTMINER_T17E = 8
-    MINER_MODEL_ANTMINER_T17_PLUS = 9
-    MINER_MODEL_ANTMINER_X19 = 10
-    MINER_MODEL_ANTMINER_S19 = 11
-    MINER_MODEL_ANTMINER_S19_PRO = 12
-    MINER_MODEL_ANTMINER_S19_PLUS = 13
-    MINER_MODEL_ANTMINER_S19J = 14
-    MINER_MODEL_ANTMINER_S19J_PRO = 15
-    MINER_MODEL_ANTMINER_S19A = 16
-    MINER_MODEL_ANTMINER_S19A_PRO = 17
-    MINER_MODEL_ANTMINER_S19XP = 18
-    MINER_MODEL_ANTMINER_T19 = 19
-    MINER_MODEL_ANTMINER_S19J_PRO_PLUS = 20
+    UNSPECIFIED = 0
+    ANTMINER_S9 = 1
+    ANTMINER_X17 = 2
+    ANTMINER_S17 = 3
+    ANTMINER_S17_PLUS = 4
+    ANTMINER_S17_PRO = 5
+    ANTMINER_S17E = 6
+    ANTMINER_T17 = 7
+    ANTMINER_T17E = 8
+    ANTMINER_T17_PLUS = 9
+    ANTMINER_X19 = 10
+    ANTMINER_S19 = 11
+    ANTMINER_S19_PRO = 12
+    ANTMINER_S19_PLUS = 13
+    ANTMINER_S19J = 14
+    ANTMINER_S19J_PRO = 15
+    ANTMINER_S19A = 16
+    ANTMINER_S19A_PRO = 17
+    ANTMINER_S19XP = 18
+    ANTMINER_T19 = 19
+    ANTMINER_S19J_PRO_PLUS = 20
 
 
 class MinerStatus(betterproto.Enum):
-    MINER_STATUS_UNSPECIFIED = 0
-    MINER_STATUS_NOT_STARTED = 1
-    MINER_STATUS_NORMAL = 2
-    MINER_STATUS_PAUSED = 3
-    MINER_STATUS_SUSPENDED = 4
-    MINER_STATUS_RESTRICTED = 5
+    UNSPECIFIED = 0
+    NOT_STARTED = 1
+    NORMAL = 2
+    PAUSED = 3
+    SUSPENDED = 4
+    RESTRICTED = 5
 
 
 class SupportArchiveFormat(betterproto.Enum):
     """Enumeration for support archive format"""
 
-    SUPPORT_ARCHIVE_FORMAT_UNSPECIFIED = 0
-    SUPPORT_ARCHIVE_FORMAT_ZIP = 1
+    UNSPECIFIED = 0
+    ZIP = 1
     """Compressed zip format"""
 
-    SUPPORT_ARCHIVE_FORMAT_BOS = 2
+    BOS = 2
     """BOS custom format"""
 
+    ZIP_ENCRYPTED = 3
+    """Compressed encrypted zip format"""
+
 
 class NetworkProtocol(betterproto.Enum):
-    NETWORK_PROTOCOL_UNSPECIFIED = 0
-    NETWORK_PROTOCOL_DHCP = 1
-    NETWORK_PROTOCOL_STATIC = 2
+    UNSPECIFIED = 0
+    DHCP = 1
+    STATIC = 2
 
 
 @dataclass(eq=False, repr=False)
@@ -268,8 +279,8 @@ class LoginResponse(betterproto.Message):
 
     timeout_s: int = betterproto.uint32_field(2)
     """
-    Authentication token validity/timeout in seconds. Token validity refreshed
-    to this value with each request.
+    Authentication token validity/timeout in seconds.
+     Token validity refreshed to this value with each request.
     """
 
 
@@ -277,9 +288,7 @@ class LoginResponse(betterproto.Message):
 class SetPasswordRequest(betterproto.Message):
     """Request for set password action."""
 
-    password: Optional[str] = betterproto.string_field(
-        1, optional=True, group="_password"
-    )
+    password: Optional[str] = betterproto.string_field(1, optional=True)
 
 
 @dataclass(eq=False, repr=False)
@@ -335,8 +344,8 @@ class BasesPoints(betterproto.Message):
 
     bsp: int = betterproto.uint32_field(1)
     """
-    A basis point is one hundredth of 1 percentage point. For example: 1bps =
-    0.01%, 250bps = 2.5%
+    A basis point is one hundredth of 1 percentage point.
+     For example: 1bps = 0.01%, 250bps = 2.5%
     """
 
 
@@ -409,9 +418,9 @@ class VoltageConstraints(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class CoolingAutoMode(betterproto.Message):
     """
-    The temperature control modes. Miner software tries to regulate the fan
-    speed so that miner temperature is approximately at the target temperature.
-    The allowed temperature range is 0-200 degree Celsius.
+    The temperature control modes.
+     Miner software tries to regulate the fan speed so that miner temperature is approximately at the target temperature.
+     The allowed temperature range is 0-200 degree Celsius.
     """
 
     target_temperature: "Temperature" = betterproto.message_field(1)
@@ -422,8 +431,7 @@ class CoolingAutoMode(betterproto.Message):
 
     dangerous_temperature: "Temperature" = betterproto.message_field(3)
     """
-    Temperature threshold at which BOSMiner shuts down in order to prevent
-    overheating and damaging the miner.
+    Temperature threshold at which BOSMiner shuts down in order to prevent overheating and damaging the miner.
     """
 
 
@@ -433,12 +441,11 @@ class CoolingManualMode(betterproto.Message):
     Fans are kept at a fixed, user-defined speed, no matter the temperature.
     """
 
-    fan_speed_ratio: Optional[float] = betterproto.double_field(
-        1, optional=True, group="_fan_speed_ratio"
-    )
+    fan_speed_ratio: Optional[float] = betterproto.double_field(1, optional=True)
     """
-    User defined fan speed expressed as a ratio between 0.0 and 1.0 where 0.0
-    means completely turned off and 1.0 means running at full speed possible
+    User defined fan speed expressed as a ratio between 0.0 and 1.0
+     where 0.0 means completely turned off and
+     1.0 means running at full speed possible
     """
 
     hot_temperature: "Temperature" = betterproto.message_field(2)
@@ -446,8 +453,7 @@ class CoolingManualMode(betterproto.Message):
 
     dangerous_temperature: "Temperature" = betterproto.message_field(3)
     """
-    Temperature threshold at which BOSMiner shuts down in order to prevent
-    overheating and damaging the miner.
+    Temperature threshold at which BOSMiner shuts down in order to prevent overheating and damaging the miner.
     """
 
 
@@ -455,20 +461,17 @@ class CoolingManualMode(betterproto.Message):
 class CoolingDisabledMode(betterproto.Message):
     """Disable temperature control. May be dangerous."""
 
-    fan_speed_ratio: Optional[float] = betterproto.double_field(
-        1, optional=True, group="_fan_speed_ratio"
-    )
+    fan_speed_ratio: Optional[float] = betterproto.double_field(1, optional=True)
     """
-    User defined fan speed expressed as a ratio between 0.0 and 1.0 where 0.0
-    means completely turned off and 1.0 means running at full speed possible
+    User defined fan speed expressed as a ratio between 0.0 and 1.0
+     where 0.0 means completely turned off and
+     1.0 means running at full speed possible
     """
 
 
 @dataclass(eq=False, repr=False)
 class CoolingConfiguration(betterproto.Message):
-    minimum_required_fans: Optional[int] = betterproto.uint32_field(
-        1, optional=True, group="_minimum_required_fans"
-    )
+    minimum_required_fans: Optional[int] = betterproto.uint32_field(1, optional=True)
     auto: "CoolingAutoMode" = betterproto.message_field(2, group="mode")
     manual: "CoolingManualMode" = betterproto.message_field(3, group="mode")
     disabled: "CoolingDisabledMode" = betterproto.message_field(4, group="mode")
@@ -488,23 +491,19 @@ class CoolingConstraints(betterproto.Message):
 class FanState(betterproto.Message):
     """Structure which contain info about one specific miner fan."""
 
-    position: Optional[int] = betterproto.uint32_field(
-        1, optional=True, group="_position"
-    )
+    position: Optional[int] = betterproto.uint32_field(1, optional=True)
     """Fan positions/ID"""
 
     rpm: int = betterproto.uint32_field(2)
     """Actual fan RPM (Revolutions/Rotation Per Minute)"""
 
-    target_speed_ratio: Optional[float] = betterproto.double_field(
-        3, optional=True, group="_target_speed_ratio"
-    )
+    target_speed_ratio: Optional[float] = betterproto.double_field(3, optional=True)
     """Actual fan speed ratio(PWM) in range 0.0 - 1.0"""
 
 
 @dataclass(eq=False, repr=False)
 class TemperatureSensor(betterproto.Message):
-    id: Optional[int] = betterproto.uint32_field(1, optional=True, group="_id")
+    id: Optional[int] = betterproto.uint32_field(1, optional=True)
     """Sensor id"""
 
     location: "SensorLocation" = betterproto.enum_field(2)
@@ -523,7 +522,10 @@ class GetCoolingStateRequest(betterproto.Message):
 
 @dataclass(eq=False, repr=False)
 class GetCoolingStateResponse(betterproto.Message):
-    """Response to get current fan states and temperature measurements"""
+    """
+    Response to get current fan states and
+     temperature measurements
+    """
 
     fans: List["FanState"] = betterproto.message_field(1)
     """All Fans state"""
@@ -551,12 +553,10 @@ class SetImmersionModeResponse(betterproto.Message):
 
 @dataclass(eq=False, repr=False)
 class TunerConfiguration(betterproto.Message):
-    enabled: Optional[bool] = betterproto.bool_field(1, optional=True, group="_enabled")
+    enabled: Optional[bool] = betterproto.bool_field(1, optional=True)
     """Flag if tuner is enabled"""
 
-    tuner_mode: Optional["TunerMode"] = betterproto.enum_field(
-        2, optional=True, group="_tuner_mode"
-    )
+    tuner_mode: Optional["TunerMode"] = betterproto.enum_field(2, optional=True)
     """Tuner mode"""
 
     power_target: "Power" = betterproto.message_field(3)
@@ -583,7 +583,7 @@ class TunerConstraints(betterproto.Message):
 
 @dataclass(eq=False, repr=False)
 class DpsConfiguration(betterproto.Message):
-    enabled: Optional[bool] = betterproto.bool_field(1, optional=True, group="_enabled")
+    enabled: Optional[bool] = betterproto.bool_field(1, optional=True)
     """Flag if Dynamic Performance Scaling is enabled"""
 
     power_step: "Power" = betterproto.message_field(2)
@@ -598,9 +598,7 @@ class DpsConfiguration(betterproto.Message):
     min_hashrate_target: "TeraHashrate" = betterproto.message_field(5)
     """Dynamic Performance Scaling minimal hashrate target"""
 
-    shutdown_enabled: Optional[bool] = betterproto.bool_field(
-        6, optional=True, group="_shutdown_enabled"
-    )
+    shutdown_enabled: Optional[bool] = betterproto.bool_field(6, optional=True)
     """Flag if shutdown for Dynamic Performance Scaling is enabled"""
 
     shutdown_duration: "Hours" = betterproto.message_field(7)
@@ -879,17 +877,13 @@ class SetDpsRequest(betterproto.Message):
     save_action: "SaveAction" = betterproto.enum_field(1)
     """Save action"""
 
-    enable: Optional[bool] = betterproto.bool_field(2, optional=True, group="_enable")
+    enable: Optional[bool] = betterproto.bool_field(2, optional=True)
     """Flag if Dynamic Performance Scaling should be enabled"""
 
-    enable_shutdown: Optional[bool] = betterproto.bool_field(
-        3, optional=True, group="_enable_shutdown"
-    )
+    enable_shutdown: Optional[bool] = betterproto.bool_field(3, optional=True)
     """Flag if shutdown for Dynamic Performance Scaling should be enabled"""
 
-    shutdown_duration: Optional["Hours"] = betterproto.message_field(
-        4, optional=True, group="_shutdown_duration"
-    )
+    shutdown_duration: Optional["Hours"] = betterproto.message_field(4, optional=True)
     """Dynamic Performance Scaling shutdown duration"""
 
     target: "DpsTarget" = betterproto.message_field(5)
@@ -898,17 +892,13 @@ class SetDpsRequest(betterproto.Message):
 
 @dataclass(eq=False, repr=False)
 class SetDpsResponse(betterproto.Message):
-    enabled: Optional[bool] = betterproto.bool_field(1, optional=True, group="_enabled")
+    enabled: Optional[bool] = betterproto.bool_field(1, optional=True)
     """Flag if Dynamic Performance Scaling is enabled"""
 
-    shutdown_enabled: Optional[bool] = betterproto.bool_field(
-        2, optional=True, group="_shutdown_enabled"
-    )
+    shutdown_enabled: Optional[bool] = betterproto.bool_field(2, optional=True)
     """Flag if shutdown for Dynamic Performance Scaling should be enabled"""
 
-    shutdown_duration: Optional["Hours"] = betterproto.message_field(
-        3, optional=True, group="_shutdown_duration"
-    )
+    shutdown_duration: Optional["Hours"] = betterproto.message_field(3, optional=True)
     """Dynamic Performance Scaling shutdown duration"""
 
     power_target: "DpsPowerTarget" = betterproto.message_field(4)
@@ -935,7 +925,7 @@ class HashboardConfig(betterproto.Message):
     id: str = betterproto.string_field(1)
     """Hashboard id"""
 
-    enabled: Optional[bool] = betterproto.bool_field(2, optional=True, group="_enabled")
+    enabled: Optional[bool] = betterproto.bool_field(2, optional=True)
     """Flag if HB si enabled"""
 
     frequency: "Frequency" = betterproto.message_field(3)
@@ -1019,9 +1009,9 @@ class Quota(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class FixedShareRatio(betterproto.Message):
     """
-    Structure for fixed share ratio load balance strategy Fixed share ratio is
-    value between 0.0 to 1.0 where 1.0 represents that all work is generated
-    from the group
+    Structure for fixed share ratio load balance strategy
+     Fixed share ratio is value between 0.0 to 1.0 where 1.0 represents that all work is
+     generated from the group
     """
 
     value: float = betterproto.double_field(1)
@@ -1058,12 +1048,10 @@ class PoolConfiguration(betterproto.Message):
     user: str = betterproto.string_field(3)
     """Pool connection user"""
 
-    password: Optional[str] = betterproto.string_field(
-        4, optional=True, group="_password"
-    )
+    password: Optional[str] = betterproto.string_field(4, optional=True)
     """Pool connection password if set"""
 
-    enabled: Optional[bool] = betterproto.bool_field(5, optional=True, group="_enabled")
+    enabled: Optional[bool] = betterproto.bool_field(5, optional=True)
     """Flag if pool connection is enabled"""
 
 
@@ -1130,9 +1118,7 @@ class PoolStats(betterproto.Message):
     generated_work: int = betterproto.uint64_field(6)
     """Generated work"""
 
-    last_share_time: Optional[datetime] = betterproto.message_field(
-        7, optional=True, group="_last_share_time"
-    )
+    last_share_time: Optional[datetime] = betterproto.message_field(7, optional=True)
     """Last share time"""
 
 
@@ -1154,9 +1140,9 @@ class GetPoolGroupsResponse(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class CreatePoolGroupRequest(betterproto.Message):
     """
-    Request for pool group create action group.uid must not be specified (it
-    will be generated) group.pools[].uid must not be specified (it will be
-    generated)
+    Request for pool group create action
+     group.uid must not be specified (it will be generated)
+     group.pools[].uid must not be specified (it will be generated)
     """
 
     save_action: "SaveAction" = betterproto.enum_field(1)
@@ -1177,9 +1163,9 @@ class CreatePoolGroupResponse(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class UpdatePoolGroupRequest(betterproto.Message):
     """
-    Request for pool group update action group.uid must be specified and
-    represents unique id of group which will be updated group.pools[].uid must
-    not be specified (it will be generated)
+    Request for pool group update action
+     group.uid must be specified and represents unique id of group which will be updated
+     group.pools[].uid must not be specified (it will be generated)
     """
 
     save_action: "SaveAction" = betterproto.enum_field(1)
@@ -1221,16 +1207,15 @@ class SetPoolGroupsRequest(betterproto.Message):
 
     save_action: "SaveAction" = betterproto.enum_field(1)
     """
-    Save action SAVE just update config but changes will not be applied
-    SAVE_AND_APPLY and SAVE_AND_FORCE_APPLY are equal for this method. Pools
-    config will be updated and changes will be applied that will trigger
-    restart.
+    Save action
+     SAVE just update config but changes will not be applied
+     SAVE_AND_APPLY and SAVE_AND_FORCE_APPLY are equal for this method. Pools config will be updated and changes will be applied that will trigger restart.
     """
 
     pool_groups: List["PoolGroupConfiguration"] = betterproto.message_field(2)
     """
-    Pool groups configuration `uid` must not be specified (it will be
-    generated)
+    Pool groups configuration
+     `uid` must not be specified (it will be generated)
     """
 
 
@@ -1292,9 +1277,8 @@ class NoneLicense(betterproto.Message):
     time_to_restricted: int = betterproto.uint32_field(1)
     """
     BOS Initialization timeout - number of seconds elapsed since bosminer start
-    i.e., number of seconds BOS will start mining in restricted mode burning 5%
-    of hashrate For more, see Section 3.10 of
-    https://braiins.com/os/plus/license
+     i.e., number of seconds BOS will start mining in restricted mode burning 5% of hashrate
+     For more, see Section 3.10 of https://braiins.com/os/plus/license
     """
 
 
@@ -1313,9 +1297,8 @@ class ValidLicense(betterproto.Message):
 
     time_to_restricted: int = betterproto.uint32_field(3)
     """
-    Current license expiration - number of seconds since the moment the license
-    was received i.e., number of seconds BOS will start mining in restricted
-    mode burning 15% of hashrate
+    Current license expiration - number of seconds since the moment the license was received
+     i.e., number of seconds BOS will start mining in restricted mode burning 15% of hashrate
     """
 
     dev_fee: "BasesPoints" = betterproto.message_field(4)
@@ -1388,7 +1371,8 @@ class MinerIdentity(betterproto.Message):
     brand: "MinerBrand" = betterproto.enum_field(1)
     model: "MinerModel" = betterproto.enum_field(2)
     """
-    Deprecated: Use miner_model instead. This field is no longer supported.
+    Deprecated: Use miner_model instead.
+     This field is no longer supported.
     """
 
     name: str = betterproto.string_field(3)
@@ -1564,7 +1548,7 @@ class Hashboard(betterproto.Message):
     stats: "WorkSolverStats" = betterproto.message_field(8)
     """Hashboard stats"""
 
-    model: Optional[str] = betterproto.string_field(9, optional=True, group="_model")
+    model: Optional[str] = betterproto.string_field(9, optional=True)
     """Hashboard model"""
 
 
@@ -1644,9 +1628,7 @@ class GetNetworkConfigurationResponse(betterproto.Message):
 class SetNetworkConfigurationRequest(betterproto.Message):
     dhcp: "Dhcp" = betterproto.message_field(1, group="protocol")
     static: "Static" = betterproto.message_field(2, group="protocol")
-    hostname: Optional[str] = betterproto.string_field(
-        3, optional=True, group="_hostname"
-    )
+    hostname: Optional[str] = betterproto.string_field(3, optional=True)
     """Hostname. Existing value will be preserved if this field is not set."""
 
 
@@ -1691,27 +1673,21 @@ class GetNetworkInfoRequest(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class GetNetworkInfoResponse(betterproto.Message):
     """
-    Response message for GetCurrentNetworkConfiguration Represents the current
-    network configuration for the default network interface. Only IPv4 is
-    supported.
+    Response message for GetCurrentNetworkConfiguration
+     Represents the current network configuration for the default network interface.
+     Only IPv4 is supported.
     """
 
     name: str = betterproto.string_field(1)
     """Name of the network interface"""
 
-    mac_address: Optional[str] = betterproto.string_field(
-        2, optional=True, group="_mac_address"
-    )
+    mac_address: Optional[str] = betterproto.string_field(2, optional=True)
     """MAC address of the network interface"""
 
-    hostname: Optional[str] = betterproto.string_field(
-        3, optional=True, group="_hostname"
-    )
+    hostname: Optional[str] = betterproto.string_field(3, optional=True)
     """Miner hostname"""
 
-    protocol: Optional["NetworkProtocol"] = betterproto.enum_field(
-        4, optional=True, group="_protocol"
-    )
+    protocol: Optional["NetworkProtocol"] = betterproto.enum_field(4, optional=True)
     """Network protocol"""
 
     dns_servers: List[str] = betterproto.string_field(5)
@@ -1720,9 +1696,7 @@ class GetNetworkInfoResponse(betterproto.Message):
     networks: List["IpNetwork"] = betterproto.message_field(6)
     """List of assigned IP addresses"""
 
-    default_gateway: Optional[str] = betterproto.string_field(
-        7, optional=True, group="_default_gateway"
-    )
+    default_gateway: Optional[str] = betterproto.string_field(7, optional=True)
     """Default gateway/route for the interface"""
 
 
@@ -2332,7 +2306,7 @@ class MinerServiceStub(betterproto.ServiceStub):
         timeout: Optional[float] = None,
         deadline: Optional["Deadline"] = None,
         metadata: Optional["MetadataLike"] = None
-    ) -> AsyncIterator["GetMinerStatusResponse"]:
+    ) -> AsyncIterator[GetMinerStatusResponse]:
         async for response in self._unary_stream(
             "/braiins.bos.v1.MinerService/GetMinerStatus",
             get_miner_status_request,
@@ -2418,7 +2392,7 @@ class MinerServiceStub(betterproto.ServiceStub):
         timeout: Optional[float] = None,
         deadline: Optional["Deadline"] = None,
         metadata: Optional["MetadataLike"] = None
-    ) -> AsyncIterator["GetSupportArchiveResponse"]:
+    ) -> AsyncIterator[GetSupportArchiveResponse]:
         async for response in self._unary_stream(
             "/braiins.bos.v1.MinerService/GetSupportArchive",
             get_support_archive_request,
@@ -3195,7 +3169,7 @@ class MinerServiceBase(ServiceBase):
 
     async def get_miner_status(
         self, get_miner_status_request: "GetMinerStatusRequest"
-    ) -> AsyncIterator["GetMinerStatusResponse"]:
+    ) -> AsyncIterator[GetMinerStatusResponse]:
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
         yield GetMinerStatusResponse()
 
@@ -3221,7 +3195,7 @@ class MinerServiceBase(ServiceBase):
 
     async def get_support_archive(
         self, get_support_archive_request: "GetSupportArchiveRequest"
-    ) -> AsyncIterator["GetSupportArchiveResponse"]:
+    ) -> AsyncIterator[GetSupportArchiveResponse]:
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
         yield GetSupportArchiveResponse()
 

pyasic/web/iceriver.py

@@ -0,0 +1,77 @@
+# ------------------------------------------------------------------------------
+#  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 __future__ import annotations
+
+import asyncio
+import warnings
+from typing import Any
+
+import httpx
+
+from pyasic import settings
+from pyasic.errors import APIError
+from pyasic.web.base import BaseWebAPI
+
+
+class IceRiverWebAPI(BaseWebAPI):
+    def __init__(self, ip: str) -> None:
+        super().__init__(ip)
+        self.username = "admin"
+        self.pwd = settings.get("default_iceriver_web_password", "12345678")
+
+    async def multicommand(
+        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
+    ) -> dict:
+        tasks = {c: asyncio.create_task(getattr(self, c)()) for c in commands}
+        await asyncio.gather(*[t for t in tasks.values()])
+        return {t: tasks[t].result() for t in tasks}
+
+    async def send_command(
+        self,
+        command: str | bytes,
+        ignore_errors: bool = False,
+        allow_warning: bool = True,
+        privileged: bool = False,
+        **parameters: Any,
+    ) -> dict:
+        async with httpx.AsyncClient(transport=settings.transport()) as client:
+            try:
+                # auth
+                await client.post(
+                    f"http://{self.ip}:{self.port}/user/loginpost",
+                    params={"post": "6", "user": self.username, "pwd": self.pwd},
+                )
+            except httpx.HTTPError:
+                warnings.warn(f"Could not authenticate with miner web: {self}")
+            try:
+                resp = await client.post(
+                    f"http://{self.ip}:{self.port}/user/{command}", params=parameters
+                )
+                if not resp.status_code == 200:
+                    if not ignore_errors:
+                        raise APIError(f"Command failed: {command}")
+                    warnings.warn(f"Command failed: {command}")
+                return resp.json()
+            except httpx.HTTPError:
+                raise APIError(f"Command failed: {command}")
+
+    async def locate(self, enable: bool):
+        return await self.send_command(
+            "userpanel", post="5", locate="1" if enable else "0"
+        )
+
+    async def userpanel(self):
+        return await self.send_command("userpanel", post="4")

pyasic/web/innosilicon.py

@@ -127,6 +127,9 @@ class InnosiliconWebAPI(BaseWebAPI):
     async def get_all(self) -> dict:
         return await self.send_command("getAll")
 
+    async def summary(self) -> dict:
+        return await self.send_command("summary")
+
     async def get_error_detail(self) -> dict:
         return await self.send_command("getErrorDetail")
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.59.0"
+version = "0.61.5"
 description = "A simplified and standardized interface for Bitcoin ASICs."
 authors = ["UpstreamData <brett@upstreamdata.ca>"]
 repository = "https://github.com/UpstreamData/pyasic"
@@ -8,20 +8,21 @@ documentation = "https://pyasic.readthedocs.io/en/latest/"
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
 httpx = ">=0.26.0"
-asyncssh = "^2.14.2"
-passlib = "^1.7.4"
-pyaml = "^23.12.0"
-toml = "^0.10.2"
-betterproto = "2.0.0b6"
-aiofiles = "^23.2.1"
+asyncssh = ">=2.17.0"
+passlib = ">=1.7.4"
+pyaml = ">=23.12.0"
+tomli = { version = ">=2.0.1", python = "<3.11" }
+tomli-w = "^1.0.0"
+betterproto = "2.0.0b7"
+aiofiles = ">=23.2.1"
 
 [tool.poetry.group.dev]
 optional = true
 
 [tool.poetry.group.dev.dependencies]
-pre-commit = "^3.1.0"
+pre-commit = "^4.0.1"
 isort = "^5.12.0"
 
 [tool.poetry.group.docs]