version: bump version number

* feature: add mining mode preset for luxos

* bug: fix type hint

.github/workflows/python-publish.yml

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

.pre-commit-config.yaml

@@ -1,12 +1,21 @@
+ci:
+  skip:
+    - unittest
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v5.0.0
     hooks:
     -   id: trailing-whitespace
     -   id: check-yaml
+        name: check-yaml for mkdocs.yml
+        files: ^mkdocs\.yml$
+        args: [--unsafe]
+    -   id: check-yaml
+        name: check-yaml for other YAML files
+        exclude: ^mkdocs\.yml$
     -   id: check-added-large-files
 -   repo: https://github.com/psf/black
-    rev: 24.3.0
+    rev: 24.10.0
     hooks:
     -   id: black
 -   repo: https://github.com/pycqa/isort
@@ -24,4 +33,3 @@ repos:
         'types': [python]
         args: ["-p '*test.py'"] # Probably this option is absolutely not needed.
         pass_filenames: false
-        stages: [commit]

.readthedocs.yaml

@@ -1,20 +1,18 @@
 # .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
 version: 2
 
 # Set the version of Python and other tools you might need
 build:
   os: ubuntu-20.04
-  tools:
-    python: "3.9"
+  tools: { python: "3.11" }
+  jobs:
+    pre_create_environment:
+      - asdf plugin add poetry
+      - asdf install poetry latest
+      - asdf global poetry latest
+      - poetry config virtualenvs.create false
+    post_install:
+      - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH poetry install --only docs
 
 mkdocs:
-  configuration: mkdocs.yml
-
-# Optionally declare the Python requirements required to build your docs
-python:
-   install:
-   - requirements: docs/requirements.txt
+  configuration: mkdocs.yml

docs/generate_miners.py

@@ -51,6 +51,12 @@ 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"
+        case MinerTypes.HAMMER:
+            return "Stock Firmware Hammer Miners"
+        case MinerTypes.VOLCMINER:
+            return "Stock Firmware Volcminers"
 
 
 def create_url_str(mtype: str):
@@ -65,7 +71,13 @@ def create_url_str(mtype: str):
 
 HEADER_FORMAT = "# pyasic\n## {} Models\n\n"
 MINER_HEADER_FORMAT = "## {}\n"
-DATA_FORMAT = """::: {}
+DATA_FORMAT = """
+- [{}] Shutdowns
+- [{}] Power Modes
+- [{}] Setpoints
+- [{}] Presets
+
+    ::: {}
     handler: python
     options:
         show_root_heading: false
@@ -77,6 +89,8 @@ SUPPORTED_TYPES_HEADER = """# pyasic
 
 Supported miner types are here on this list.  If your miner (or miner version) is not on this list, please feel free to [open an issue on GitHub](https://github.com/UpstreamData/pyasic/issues) to get it added.
 
+Keep in mind that some functionality is only supported for specific miners or firmwares, please check the page for your miner to make sure the functionality you need is supported.
+
 ##### pyasic currently supports the following miners and subtypes:
 <style>
 details {
@@ -134,9 +148,18 @@ async def create_directory_structure(directory, data):
             with open(file_path, "w") as file:
                 file.write(HEADER_FORMAT.format(key))
                 for item in value:
-                    header = await item("1.1.1.1").get_model()
+                    obj = item("1.1.1.1")
+                    header = obj.model
                     file.write(MINER_HEADER_FORMAT.format(header))
-                    file.write(DATA_FORMAT.format(path(item)))
+                    file.write(
+                        DATA_FORMAT.format(
+                            "x" if obj.supports_shutdown else " ",
+                            "x" if obj.supports_power_modes else " ",
+                            "x" if obj.supports_autotuning else " ",
+                            "x" if obj.supports_presets else " ",
+                            path(item),
+                        )
+                    )
 
 
 async def create_supported_types(directory):

docs/index.md

@@ -11,145 +11,149 @@
 [![Read The Docs - Docs](https://img.shields.io/readthedocs/pyasic)](https://pyasic.readthedocs.io/en/latest/)
 [![License - Apache 2.0](https://img.shields.io/github/license/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/blob/master/LICENSE.txt)
 
----
 ## Intro
 ---
 Welcome to `pyasic`!  `pyasic` uses an asynchronous method of communicating with ASIC miners on your network, which makes it super fast.
 
 [Click here to view supported miner types](miners/supported_types.md)
 
----
 ## Installation
-
-It is recommended to install `pyasic` in a [virtual environment](https://realpython.com/python-virtual-environments-a-primer/#what-other-popular-options-exist-aside-from-venv) to isolate it from the rest of your system. Options include:
-  - [pypoetry](https://python-poetry.org/): the reccommended way, since pyasic already uses it by default
-
-```
-    poetry install
-```
-
-  - [venv](https://docs.python.org/3/library/venv.html): included in Python standard library but has fewer features than other options
-  - [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv): [pyenv](https://github.com/pyenv/pyenv) plugin for managing virtualenvs
-
-```
-    pyenv install <python version number>
-    pyenv virtualenv <python version number> <env name>
-    pyenv activate <env name>
-```
-
-  - [conda](https://docs.conda.io/en/latest/)
-
-##### Installing `pyasic`
-
-`python -m pip install pyasic` or `poetry install`
-
 ---
+It is recommended to install `pyasic` in a [virtual environment](https://realpython.com/python-virtual-environments-a-primer/#what-other-popular-options-exist-aside-from-venv) to isolate it from the rest of your system.
+`pyasic` can be installed directly from pip, either with `pip install pyasic`, or a different command if using a tool like `pypoetry`.
+
 ## Getting started
 ---
 Getting started with `pyasic` is easy.  First, find your miner (or miners) on the network by scanning for them or getting the correct class automatically for them if you know the IP.
 
-##### Scanning for miners
+### Scanning for miners
 To scan for miners in `pyasic`, we use the class [`MinerNetwork`][pyasic.network.MinerNetwork], which abstracts the search, communication, identification, setup, and return of a miner to 1 command.
 The command [`MinerNetwork.scan()`][pyasic.network.MinerNetwork.scan] returns a list that contains any miners found.
-```python
-import asyncio  # asyncio for handling the async part
-from pyasic.network import MinerNetwork  # miner network handles the scanning
+```python3
+import asyncio# (1)!
+from pyasic.network import MinerNetwork# (2)!
 
 
-async def scan_miners():  # define async scan function to allow awaiting
-    # create a miner network
-    # you can pass in any IP and it will use that in a subnet with a /24 mask (255 IPs).
-    network = MinerNetwork.from_subnet("192.168.1.50/24")  # this uses the 192.168.1.0-255 network
+async def scan_miners():# (3)!
+    network = MinerNetwork.from_subnet("192.168.1.50/24")# (4)!
 
-    # scan for miners asynchronously
-    # this will return the correct type of miners if they are supported with all functionality.
-    miners = await network.scan()
+    miners = await network.scan()# (5)!
     print(miners)
 
 if __name__ == "__main__":
-    asyncio.run(scan_miners())  # run the scan asynchronously with asyncio.run()
+    asyncio.run(scan_miners())# (6)!
 ```
 
+1. `asyncio` for handling the async part.
+2. `MinerNetwork` handles the scanning.
+3. Define an async function to allow awaiting.
+4. Create a miner network.
+You can pass in any IP and it will use that in a subnet with a /24 mask (255 IPs).
+This uses the 192.168.1.0-255 network.
+5. Scan for miners asynchronously.
+This will return the correct type of miners (if they are supported) with all functionality.
+6. Run the scan asynchronously with asyncio.run().
+
 ---
-##### Creating miners based on IP
+### Creating miners based on IP
 If you already know the IP address of your miner or miners, you can use the [`MinerFactory`][pyasic.miners.factory.MinerFactory] to communicate and identify the miners, or an abstraction of its functionality, [`get_miner()`][pyasic.miners.get_miner].
 The function [`get_miner()`][pyasic.miners.get_miner] will return any miner it found at the IP address specified, or an `UnknownMiner` if it cannot identify the miner.
 ```python
-import asyncio  # asyncio for handling the async part
-from pyasic import get_miner # handles miner creation
+import asyncio# (1)!
+from pyasic import get_miner# (2)!
 
 
-async def get_miners():  # define async scan function to allow awaiting
-    # get the miner with the miner factory
-    # the miner factory is a singleton, and will always use the same object and cache
-    # this means you can always call it as MinerFactory().get_miner(), or just get_miner()
-    miner_1 = await get_miner("192.168.1.75")
+async def get_miners():# (3)!
+    miner_1 = await get_miner("192.168.1.75")# (4)!
     miner_2 = await get_miner("192.168.1.76")
     print(miner_1, miner_2)
 
-    # can also gather these, since they are async
-    # gathering them will get them both at the same time
-    # this makes it much faster to get a lot of miners at a time
     tasks = [get_miner("192.168.1.75"), get_miner("192.168.1.76")]
-    miners = await asyncio.gather(*tasks)
+    miners = await asyncio.gather(*tasks)# (5)!
     print(miners)
 
 
 if __name__ == "__main__":
-    asyncio.run(get_miners())  # get the miners asynchronously with asyncio.run()
+    asyncio.run(get_miners())# (6)!
 ```
 
----
+1. `asyncio` for handling the async part.
+2. `get_miner` handles the miner type selection.
+3. Define an async function to allow awaiting.
+4. Get the miner.
+5. Can also gather these, since they are async.
+Gathering them will get them both at the same time.
+This makes it much faster to get a lot of miners at a time.
+6. Get the miners asynchronously with asyncio.run().
+
 ## Data gathering
 ---
 Once you have your miner(s) identified, you will likely want to get data from the miner(s).  You can do this using a built-in function in each miner called `get_data()`.
 This function will return an instance of the dataclass [`MinerData`][pyasic.data.MinerData] with all data it can gather from the miner.
 Each piece of data in a [`MinerData`][pyasic.data.MinerData] instance can be referenced by getting it as an attribute, such as [`MinerData().hashrate`][pyasic.data.MinerData].
 
-##### One miner
+### One miner
 ```python
-import asyncio
-from pyasic import get_miner
+import asyncio# (1)!
+from pyasic import get_miner# (2)!
 
-async def gather_miner_data():
-    miner = await get_miner("192.168.1.75")
-    if miner is not None:
-        miner_data = await miner.get_data()
-        print(miner_data)  # all data from the dataclass
+
+async def gather_miner_data():# (3)!
+    miner = await get_miner("192.168.1.75")# (4)!
+    if miner is not None:# (5)!
+        miner_data = await miner.get_data()# (6)!
+        print(miner_data)# (7)!
         print(miner_data.hashrate)  # hashrate of the miner in TH/s
 
 if __name__ == "__main__":
-    asyncio.run(gather_miner_data())
+    asyncio.run(gather_miner_data())# (9)!
 ```
----
-##### Multiple miners
+
+1. `asyncio` for handling the async part.
+2. `get_miner` handles the miner type selection.
+3. Define an async function to allow awaiting.
+4. Get the miner.
+5. Make sure the miner exists.
+If this result is `None`, the miner may be offline.
+6. Get data from the miner.
+7. All the data from the dataclass.
+8. Hashrate of the miner, with unit information.
+9. Get the miner data asynchronously with asyncio.run().
+
+### Multiple miners
 You can do something similar with multiple miners, with only needing to make a small change to get all the data at once.
 ```python
-import asyncio  # asyncio for handling the async part
-from pyasic.network import MinerNetwork  # miner network handles the scanning
+import asyncio# (1)!
+from pyasic.network import MinerNetwork# (2)!
 
 
-async def gather_miner_data():  # define async scan function to allow awaiting
-    network = MinerNetwork.from_subnet("192.168.1.50/24")
-    miners = await network.scan()
+async def gather_miner_data():# (3)!
+    network = MinerNetwork.from_subnet("192.168.1.50/24")# (4)!
+    miners = await network.scan()# (5)!
 
-    # we need to asyncio.gather() all the miners get_data() functions to make them run together
     all_miner_data = await asyncio.gather(*[miner.get_data() for miner in miners])
 
     for miner_data in all_miner_data:
-        print(miner_data)    # print out all the data one by one
+        print(miner_data)# (7)!
 
 if __name__ == "__main__":
-    asyncio.run(gather_miner_data())
+    asyncio.run(gather_miner_data())# (8)!
 ```
 
----
+1. `asyncio` for handling the async part.
+2. `MinerNetwork` handles the scanning.
+3. Define an async function to allow awaiting.
+4. Create a miner network.
+5. Scan for miners asynchronously.
+6. Use `asyncio.gather()` with all the miners' `get_data()` functions to make them run together.
+7. Print out the data one at a time.
+8. Get the miner data asynchronously with asyncio.run().
+
 ## Miner control
 ---
 `pyasic` exposes a standard interface for each miner using control functions.
-Every miner class in `pyasic` must implement all the control functions defined in [`MinerProtocol`][pyasic.miners.base.MinerProtocol].
+Every miner class in `pyasic` must implement all the following control functions.
 
-These functions are
 [`check_light`][pyasic.miners.base.MinerProtocol.check_light],
 [`fault_light_off`][pyasic.miners.base.MinerProtocol.fault_light_off],
 [`fault_light_on`][pyasic.miners.base.MinerProtocol.fault_light_on],
@@ -166,35 +170,41 @@ These functions are
 [`send_config`][pyasic.miners.base.MinerProtocol.send_config], and
 [`set_power_limit`][pyasic.miners.base.MinerProtocol.set_power_limit].
 
-##### Usage
+### Usage
 ```python
-import asyncio
-from pyasic import get_miner
+import asyncio# (1)!
+from pyasic import get_miner# (2)!
 
 
-async def set_fault_light():
-    miner = await get_miner("192.168.1.20")
+async def set_fault_light():# (3)!
+    miner = await get_miner("192.168.1.20")# (4)!
 
-    # call control function
-    await miner.fault_light_on()
+    await miner.fault_light_on()# (5)!
 
 if __name__ == "__main__":
-    asyncio.run(set_fault_light())
+    asyncio.run(set_fault_light())# (6)!
 ```
 
----
+1. `asyncio` for handling the async part.
+2. `get_miner` handles the miner type selection.
+3. Define an async function to allow awaiting.
+4. Get the miner.
+5. Call the miner control function.
+6. Call the control function asynchronously with asyncio.run().
+
+
 ## Helper dataclasses
 ---
 
-##### [`MinerConfig`][pyasic.config.MinerConfig] and [`MinerData`][pyasic.data.MinerData]
+### [`MinerConfig`][pyasic.config.MinerConfig] and [`MinerData`][pyasic.data.MinerData]
 
 `pyasic` implements a few dataclasses as helpers to make data return types consistent across different miners and miner APIs.  The different fields of these dataclasses can all be viewed with the classmethod `cls.fields()`.
 
 ---
 
-##### [`MinerData`][pyasic.data.MinerData]
+### [`MinerData`][pyasic.data.MinerData]
 
-[`MinerData`][pyasic.data.MinerData] is a return from the [`get_data()`](#get-data) function, and is used to have a consistent dataset across all returns.
+[`MinerData`][pyasic.data.MinerData] is a return from the [`get_data()`][pyasic.miners.base.MinerProtocol.get_data] function, and is used to have a consistent dataset across all returns.
 
 You can call [`MinerData.as_dict()`][pyasic.data.MinerData.as_dict] to get the dataclass as a dictionary, and there are many other helper functions contained in the class to convert to different data formats.
 
@@ -213,13 +223,13 @@ average_data = sum(list_of_miner_data, start=MinerData("0.0.0.0"))/len(list_of_m
 
 ---
 
-##### [`MinerConfig`][pyasic.config.MinerConfig]
+### [`MinerConfig`][pyasic.config.MinerConfig]
 
 [`MinerConfig`][pyasic.config.MinerConfig] is `pyasic`'s way to represent a configuration file from a miner.
-It is designed to unionize the configuration of all supported miner types, and is the return from [`get_config()`](#get-config).
+It is designed to unionize the configuration of all supported miner types, and is the return from [`get_config()`][pyasic.miners.base.MinerProtocol.get_config].
 
 Each miner has a unique way to convert the [`MinerConfig`][pyasic.config.MinerConfig] to their specific type, there are helper functions in the class.
-In most cases these helper functions should not be used, as [`send_config()`](#send-config) takes a [`MinerConfig`][pyasic.config.MinerConfig] and will do the conversion to the right type for you.
+In most cases these helper functions should not be used, as [`send_config()`][pyasic.miners.base.MinerProtocol.send_config] takes a [`MinerConfig`][pyasic.config.MinerConfig] and will do the conversion to the right type for you.
 
 You can use the [`MinerConfig`][pyasic.config.MinerConfig] as follows:
 ```python
@@ -241,7 +251,6 @@ if __name__ == "__main__":
 
 ```
 
----
 ## Settings
 ---
 `pyasic` has settings designed to make using large groups of miners easier.  You can set the default password for all types of miners using the `pyasic.settings` module, used as follows:
@@ -252,7 +261,7 @@ from pyasic import settings
 settings.update("default_antminer_web_password", "my_pwd")
 ```
 
-##### Default values:
+### Default values:
 ```
 "network_ping_retries": 1,
 "network_ping_timeout": 3,

docs/miners/antminer/X15.md

@@ -2,7 +2,26 @@
 ## X15 Models
 
 ## Z15 (Stock)
-::: pyasic.miners.antminer.cgminer.X15.Z15.CGMinerZ15
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.cgminer.X15.Z15.CGMinerZ15
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Z15 Pro (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X15.Z15.BMMinerZ15Pro
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X17.md

@@ -2,112 +2,208 @@
 ## X17 Models
 
 ## S17 (Stock)
-::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17+ (Stock)
-::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17Plus
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17 Pro (Stock)
-::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17Pro
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17e (Stock)
-::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17e
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17e
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T17 (Stock)
-::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T17+ (Stock)
-::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17Plus
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T17e (Stock)
-::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17e
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17e
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17 (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17+ (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17Plus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17 Pro (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17Pro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17e (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17e
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17e
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T17 (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T17+ (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17Plus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T17e (BOS+)
-::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17e
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17e
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17+ (VNish)
-::: pyasic.miners.antminer.vnish.X17.S17.VNishS17Plus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X17.S17.VNishS17Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S17 Pro (VNish)
-::: pyasic.miners.antminer.vnish.X17.S17.VNishS17Pro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X17.S17.VNishS17Pro
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X19.md

@@ -2,434 +2,910 @@
 ## X19 Models
 
 ## S19 (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19L (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19L
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19L
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19Pro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19j
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19j
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19i (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19i
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19i
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19+ (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19Plus
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j No PIC (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jNoPIC
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro+ (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19ProPlus
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19ProPlus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jPro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 XP (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19XP
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19XP
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19a (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19a
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19a
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19a Pro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19aPro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19aPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Hydro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19Hydro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19Hydro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro Hydro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19ProHydro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19ProHydro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro+ Hydro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19ProPlusHydro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19ProPlusHydro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19K Pro (Stock)
-::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19KPro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19KPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j XP (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jXP
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T19 (Stock)
-::: pyasic.miners.antminer.bmminer.X19.T19.BMMinerT19
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X19.T19.BMMinerT19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19+ (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19Plus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19Pro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19a (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19a
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19a
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19a Pro (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19aPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19aPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19j
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19j
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j No PIC (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jNoPIC
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro No PIC (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProNoPIC
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro+ (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProPlus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProPlus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro+ (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProPlus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProPlus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro+ No PIC (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProPlusNoPIC
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19jProPlusNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19k Pro No PIC (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19kProNoPIC
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19kProNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19k Pro No PIC (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19kProNoPIC
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19kProNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 XP (BOS+)
-::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19XP
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19XP
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro+ Hydro (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: 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
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X19.T19.BOSMinerT19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 No PIC (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19NoPIC
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19NoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19Pro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19j
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19j
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19jPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19a (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19a
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19a
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19a Pro (VNish)
-::: pyasic.miners.antminer.vnish.X19.S19.VNishS19aPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19aPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro Hydro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19ProHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19k Pro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19kPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T19 (VNish)
-::: pyasic.miners.antminer.vnish.X19.T19.VNishT19
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X19.T19.VNishT19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19Pro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19j
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19j
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19jPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro+ (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19jProPlus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19jProPlus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19k Pro (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19kPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19kPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 XP (ePIC)
-::: pyasic.miners.antminer.epic.X19.S19.ePICS19XP
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19XP
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro Dual (ePIC)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X19.S19.ePICS19jProDual
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (Hive)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 (Hive)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19Pro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro+ (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jProPlus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jProPlus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19k Pro (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19kPro
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19kPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 XP (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19XP
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19XP
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T19 (LuxOS)
-::: pyasic.miners.antminer.luxos.X19.T19.LUXMinerT19
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X19.T19.LUXMinerT19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 Pro (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19Pro
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19Pro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19j
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19j
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j No PIC (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19jNoPIC
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19jNoPIC
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19j Pro (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19jPro
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19jPro
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19 XP (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19XP
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19XP
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S19K Pro (MaraFW)
-::: pyasic.miners.antminer.marathon.X19.S19.MaraS19KPro
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X19.S19.MaraS19KPro
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X21.md

@@ -2,63 +2,156 @@
 ## X21 Models
 
 ## S21 (Stock)
-::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 Pro (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: 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
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X21.T21.BMMinerT21
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S21 (BOS+)
-::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T21 (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: 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
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X21.S21.VNishS21
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S21 (ePIC)
-::: pyasic.miners.antminer.epic.X21.S21.ePICS21
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X21.S21.ePICS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 Pro (ePIC)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: 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
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.epic.X21.T21.ePICT21
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S21 (LuxOS)
-::: pyasic.miners.antminer.luxos.X21.S21.LUXMinerS21
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X21.S21.LUXMinerS21
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S21 (MaraFW)
-::: pyasic.miners.antminer.marathon.X21.S21.MaraS21
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X21.S21.MaraS21
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T21 (MaraFW)
-::: pyasic.miners.antminer.marathon.X21.T21.MaraT21
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.marathon.X21.T21.MaraT21
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X3.md

@@ -2,35 +2,91 @@
 ## X3 Models
 
 ## D3 (Stock)
-::: pyasic.miners.antminer.cgminer.X3.D3.CGMinerD3
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.cgminer.X3.D3.CGMinerD3
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## HS3 (Stock)
-::: pyasic.miners.antminer.bmminer.X3.HS3.BMMinerHS3
+
+- [ ] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X3.HS3.BMMinerHS3
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## L3+ (Stock)
-::: pyasic.miners.antminer.bmminer.X3.L3.BMMinerL3Plus
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X3.L3.BMMinerL3Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KA3 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X3.KA3.BMMinerKA3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: 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
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## L3+ (VNish)
-::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X5.md

@@ -2,7 +2,26 @@
 ## X5 Models
 
 ## DR5 (Stock)
-::: pyasic.miners.antminer.cgminer.X5.DR5.CGMinerDR5
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.cgminer.X5.DR5.CGMinerDR5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5 (Stock)
+
+- [ ] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X5.KS5.BMMinerKS5
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X7.md

@@ -2,14 +2,52 @@
 ## X7 Models
 
 ## L7 (Stock)
-::: pyasic.miners.antminer.bmminer.X7.L7.BMMinerL7
+
+- [ ] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X7.L7.BMMinerL7
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## K7 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X7.K7.BMMinerK7
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## D7 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X7.D7.BMMinerD7
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## L7 (VNish)
-::: pyasic.miners.antminer.vnish.X7.L7.VnishL7
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.vnish.X7.L7.VnishL7
     handler: python
     options:
         show_root_heading: false

docs/miners/antminer/X9.md

@@ -2,56 +2,130 @@
 ## X9 Models
 
 ## E9Pro (Stock)
-::: pyasic.miners.antminer.bmminer.X9.E9.BMMinerE9Pro
+
+- [ ] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.E9.BMMinerE9Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## D9 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.D9.BMMinerD9
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S9 (Stock)
-::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S9i (Stock)
-::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9i
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9i
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S9j (Stock)
-::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9j
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9j
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## T9 (Stock)
-::: pyasic.miners.antminer.bmminer.X9.T9.BMMinerT9
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.T9.BMMinerT9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## L9 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bmminer.X9.L9.BMMinerL9
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S9 (BOS+)
-::: pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
-## T9 (Stock)
-::: pyasic.miners.antminer.hiveon.X9.T9.HiveonT9
+## T9 (Hive)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.antminer.hiveon.X9.T9.HiveonT9
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## S9 (LuxOS)
-::: pyasic.miners.antminer.luxos.X9.S9.LUXMinerS9
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [x] Presets
+
+    ::: pyasic.miners.antminer.luxos.X9.S9.LUXMinerS9
     handler: python
     options:
         show_root_heading: false

docs/miners/auradine/AD.md

@@ -2,21 +2,39 @@
 ## AD Models
 
 ## AT1500 (Stock)
-::: pyasic.miners.auradine.flux.AD.AT1.AuradineFluxAT1500
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AD.AT1.AuradineFluxAT1500
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## AT2860 (Stock)
-::: pyasic.miners.auradine.flux.AD.AT2.AuradineFluxAT2860
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AD.AT2.AuradineFluxAT2860
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## AT2880 (Stock)
-::: pyasic.miners.auradine.flux.AD.AT2.AuradineFluxAT2880
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AD.AT2.AuradineFluxAT2880
     handler: python
     options:
         show_root_heading: false

docs/miners/auradine/AI.md

@@ -2,14 +2,26 @@
 ## AI Models
 
 ## AI2500 (Stock)
-::: pyasic.miners.auradine.flux.AI.AI2.AuradineFluxAI2500
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AI.AI2.AuradineFluxAI2500
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## AI3680 (Stock)
-::: pyasic.miners.auradine.flux.AI.AI3.AuradineFluxAI3680
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AI.AI3.AuradineFluxAI3680
     handler: python
     options:
         show_root_heading: false

docs/miners/auradine/AT.md

@@ -2,14 +2,26 @@
 ## AT Models
 
 ## AD2500 (Stock)
-::: pyasic.miners.auradine.flux.AT.AD2.AuradineFluxAD2500
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AT.AD2.AuradineFluxAD2500
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## AD3500 (Stock)
-::: pyasic.miners.auradine.flux.AT.AD3.AuradineFluxAD3500
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.auradine.flux.AT.AD3.AuradineFluxAD3500
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/A10X.md

@@ -2,21 +2,39 @@
 ## A10X Models
 
 ## Avalon 1026 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A10X.A1026.CGMinerAvalon1026
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A10X.A1026.CGMinerAvalon1026
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Avalon 1047 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A10X.A1047.CGMinerAvalon1047
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A10X.A1047.CGMinerAvalon1047
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Avalon 1066 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A10X.A1066.CGMinerAvalon1066
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A10X.A1066.CGMinerAvalon1066
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/A11X.md

@@ -1,8 +1,27 @@
 # pyasic
 ## A11X Models
 
-## Avalon 1166 Pro (Stock)
-::: pyasic.miners.avalonminer.cgminer.A11X.A1166.CGMinerAvalon1166Pro
+## Avalon 1126 Pro (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A11X.A1126.CGMinerAvalon1126Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Avalon 1166 Pro (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A11X.A1166.CGMinerAvalon1166Pro
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/A12X.md

@@ -2,7 +2,13 @@
 ## A12X Models
 
 ## Avalon 1246 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A12X.A1246.CGMinerAvalon1246
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A12X.A1246.CGMinerAvalon1246
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/A7X.md

@@ -2,21 +2,39 @@
 ## A7X Models
 
 ## Avalon 721 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A7X.A721.CGMinerAvalon721
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A7X.A721.CGMinerAvalon721
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Avalon 741 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A7X.A741.CGMinerAvalon741
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A7X.A741.CGMinerAvalon741
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Avalon 761 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A7X.A761.CGMinerAvalon761
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A7X.A761.CGMinerAvalon761
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/A8X.md

@@ -2,21 +2,39 @@
 ## A8X Models
 
 ## Avalon 821 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A8X.A821.CGMinerAvalon821
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A8X.A821.CGMinerAvalon821
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Avalon 841 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A8X.A841.CGMinerAvalon841
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A8X.A841.CGMinerAvalon841
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Avalon 851 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A8X.A851.CGMinerAvalon851
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A8X.A851.CGMinerAvalon851
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/A9X.md

@@ -2,7 +2,13 @@
 ## A9X Models
 
 ## Avalon 921 (Stock)
-::: pyasic.miners.avalonminer.cgminer.A9X.A921.CGMinerAvalon921
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.avalonminer.cgminer.A9X.A921.CGMinerAvalon921
     handler: python
     options:
         show_root_heading: false

docs/miners/avalonminer/nano.md

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

docs/miners/backends/hiveon.md

@@ -1,7 +1,14 @@
 # pyasic
-## Hiveon Backend
+## Modern Hiveon Backend
 
-::: pyasic.miners.backends.hiveon.Hiveon
+::: pyasic.miners.backends.hiveon.HiveonModern
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Old Hiveon Backend
+::: pyasic.miners.backends.hiveon.HiveonOld
     handler: python
     options:
         show_root_heading: false

docs/miners/base_miner.md

@@ -10,8 +10,3 @@ You may not instantiate this class on its own, only subclass from it.
     handler: python
     options:
         heading_level: 4
-
-::: pyasic.miners.base.MinerProtocol
-    handler: python
-    options:
-        heading_level: 4

docs/miners/bitaxe/BM.md

@@ -2,21 +2,52 @@
 ## BM Models
 
 ## Supra (Stock)
-::: pyasic.miners.bitaxe.espminer.BM.BM1368.BitAxeSupra
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.bitaxe.espminer.BM.BM1368.BitAxeSupra
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Ultra (Stock)
-::: pyasic.miners.bitaxe.espminer.BM.BM1366.BitAxeUltra
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.bitaxe.espminer.BM.BM1366.BitAxeUltra
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## Max (Stock)
-::: pyasic.miners.bitaxe.espminer.BM.BM1397.BitAxeMax
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.bitaxe.espminer.BM.BM1397.BitAxeMax
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Gamma (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.bitaxe.espminer.BM.BM1370.BitAxeGamma
     handler: python
     options:
         show_root_heading: false

docs/miners/blockminer/blockminer.md

@@ -2,14 +2,26 @@
 ## blockminer Models
 
 ## BlockMiner 520i (ePIC)
-::: pyasic.miners.blockminer.epic.blockminer.blockminer.ePICBlockMiner520i
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.blockminer.epic.blockminer.blockminer.ePICBlockMiner520i
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## BlockMiner 720i (ePIC)
-::: pyasic.miners.blockminer.epic.blockminer.blockminer.ePICBlockMiner720i
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.blockminer.epic.blockminer.blockminer.ePICBlockMiner720i
     handler: python
     options:
         show_root_heading: false

docs/miners/braiins/BMM.md

@@ -0,0 +1,29 @@
+# pyasic
+## BMM Models
+
+## BMM100 (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.braiins.braiins.BMM.BMM.BraiinsBMM100
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## BMM101 (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.braiins.braiins.BMM.BMM.BraiinsBMM101
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/functions.md

@@ -1,91 +1,10 @@
 ## Control functionality
 
-### Check Light
-::: pyasic.miners.base.MinerProtocol.check_light
-    handler: python
-    options:
-        heading_level: 4
+All control functionality is outlined by the [`MinerProtocol`][pyasic.miners.base.MinerProtocol] class.
 
-### Fault Light Off
-::: pyasic.miners.base.MinerProtocol.fault_light_off
-    handler: python
-    options:
-        heading_level: 4
+## Miner Protocol
 
-### Fault Light On
-::: pyasic.miners.base.MinerProtocol.fault_light_on
-    handler: python
-    options:
-        heading_level: 4
-
-### Get Config
-::: pyasic.miners.base.MinerProtocol.get_config
-    handler: python
-    options:
-        heading_level: 4
-
-### Get Data
-::: pyasic.miners.base.MinerProtocol.get_data
-    handler: python
-    options:
-        heading_level: 4
-
-### Get Errors
-::: pyasic.miners.base.MinerProtocol.get_errors
-    handler: python
-    options:
-        heading_level: 4
-
-### Get Hostname
-::: pyasic.miners.base.MinerProtocol.get_hostname
-    handler: python
-    options:
-        heading_level: 4
-
-### Get Model
-::: pyasic.miners.base.MinerProtocol.get_model
-    handler: python
-    options:
-        heading_level: 4
-
-### Reboot
-::: pyasic.miners.base.MinerProtocol.reboot
-    handler: python
-    options:
-        heading_level: 4
-
-### Restart Backend
-::: pyasic.miners.base.MinerProtocol.restart_backend
-    handler: python
-    options:
-        heading_level: 4
-
-### Stop Mining
-::: pyasic.miners.base.MinerProtocol.stop_mining
-    handler: python
-    options:
-        heading_level: 4
-
-### Resume Mining
-::: pyasic.miners.base.MinerProtocol.resume_mining
-    handler: python
-    options:
-        heading_level: 4
-
-### Is Mining
-::: pyasic.miners.base.MinerProtocol.is_mining
-    handler: python
-    options:
-        heading_level: 4
-
-### Send Config
-::: pyasic.miners.base.MinerProtocol.send_config
-    handler: python
-    options:
-        heading_level: 4
-
-### Set Power Limit
-::: pyasic.miners.base.MinerProtocol.set_power_limit
+::: pyasic.miners.base.MinerProtocol
     handler: python
     options:
         heading_level: 4

docs/miners/goldshell/X5.md

@@ -2,21 +2,39 @@
 ## X5 Models
 
 ## CK5 (Stock)
-::: pyasic.miners.goldshell.bfgminer.X5.CK5.GoldshellCK5
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.goldshell.bfgminer.X5.CK5.GoldshellCK5
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## HS5 (Stock)
-::: pyasic.miners.goldshell.bfgminer.X5.HS5.GoldshellHS5
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.goldshell.bfgminer.X5.HS5.GoldshellHS5
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## KD5 (Stock)
-::: pyasic.miners.goldshell.bfgminer.X5.KD5.GoldshellKD5
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.goldshell.bfgminer.X5.KD5.GoldshellKD5
     handler: python
     options:
         show_root_heading: false

docs/miners/goldshell/XBox.md

@@ -2,14 +2,26 @@
 ## XBox Models
 
 ## KD Box II (Stock)
-::: pyasic.miners.goldshell.bfgminer.XBox.KDBox.GoldshellKDBoxII
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.goldshell.bfgminer.XBox.KDBox.GoldshellKDBoxII
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## KD Box Pro (Stock)
-::: pyasic.miners.goldshell.bfgminer.XBox.KDBox.GoldshellKDBoxPro
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.goldshell.bfgminer.XBox.KDBox.GoldshellKDBoxPro
     handler: python
     options:
         show_root_heading: false

docs/miners/goldshell/XMax.md

@@ -2,7 +2,13 @@
 ## XMax Models
 
 ## KD Max (Stock)
-::: pyasic.miners.goldshell.bfgminer.XMax.KDMax.GoldshellKDMax
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.goldshell.bfgminer.XMax.KDMax.GoldshellKDMax
     handler: python
     options:
         show_root_heading: false

docs/miners/hammer/DX.md

@@ -0,0 +1,16 @@
+# pyasic
+## DX Models
+
+## D10 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.hammer.blackminer.DX.D10.HammerD10
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/iceriver/KSX.md

@@ -0,0 +1,120 @@
+# pyasic
+## KSX Models
+
+## KS0 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS0.IceRiverKS0
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS1 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS1.IceRiverKS1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS2 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS2.IceRiverKS2
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3L (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3M (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5L (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5M (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/innosilicon/A10X.md

@@ -2,7 +2,13 @@
 ## A10X Models
 
 ## A10X (Stock)
-::: pyasic.miners.innosilicon.cgminer.A10X.A10X.InnosiliconA10X
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.innosilicon.cgminer.A10X.A10X.InnosiliconA10X
     handler: python
     options:
         show_root_heading: false

docs/miners/innosilicon/A11X.md

@@ -0,0 +1,29 @@
+# pyasic
+## A11X Models
+
+## A11 (Stock)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.innosilicon.cgminer.A11X.A11.InnosiliconA11
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A11MX (Stock)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.innosilicon.cgminer.A11X.A11M.InnosiliconA11MX
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/innosilicon/T3X.md

@@ -2,7 +2,13 @@
 ## T3X Models
 
 ## T3H+ (Stock)
-::: pyasic.miners.innosilicon.cgminer.T3X.T3H.InnosiliconT3HPlus
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.innosilicon.cgminer.T3X.T3H.InnosiliconT3HPlus
     handler: python
     options:
         show_root_heading: false

docs/miners/supported_types.md

@@ -3,6 +3,8 @@
 
 Supported miner types are here on this list.  If your miner (or miner version) is not on this list, please feel free to [open an issue on GitHub](https://github.com/UpstreamData/pyasic/issues) to get it added.
 
+Keep in mind that some functionality is only supported for specific miners or firmwares, please check the page for your miner to make sure the functionality you need is supported.
+
 ##### pyasic currently supports the following miners and subtypes:
 <style>
 details {
@@ -21,34 +23,42 @@ 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>
             <summary>X7 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X7#l7-stock">L7 (Stock)</a></li>
+                    <li><a href="../antminer/X7#k7-stock">K7 (Stock)</a></li>
+                    <li><a href="../antminer/X7#d7-stock">D7 (Stock)</a></li>
                 </ul>
         </details>
         <details>
             <summary>X9 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X9#e9pro-stock">E9Pro (Stock)</a></li>
+                    <li><a href="../antminer/X9#d9-stock">D9 (Stock)</a></li>
                     <li><a href="../antminer/X9#s9-stock">S9 (Stock)</a></li>
                     <li><a href="../antminer/X9#s9i-stock">S9i (Stock)</a></li>
                     <li><a href="../antminer/X9#s9j-stock">S9j (Stock)</a></li>
                     <li><a href="../antminer/X9#t9-stock">T9 (Stock)</a></li>
+                    <li><a href="../antminer/X9#l9-stock">L9 (Stock)</a></li>
                 </ul>
         </details>
         <details>
             <summary>X15 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X15#z15-stock">Z15 (Stock)</a></li>
+                    <li><a href="../antminer/X15#z15-pro-stock">Z15 Pro (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -82,6 +92,7 @@ details {
                     <li><a href="../antminer/X19#s19-pro-hydro-stock">S19 Pro Hydro (Stock)</a></li>
                     <li><a href="../antminer/X19#s19-pro_1-hydro-stock">S19 Pro+ Hydro (Stock)</a></li>
                     <li><a href="../antminer/X19#s19k-pro-stock">S19K Pro (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j-xp-stock">S19j XP (Stock)</a></li>
                     <li><a href="../antminer/X19#t19-stock">T19 (Stock)</a></li>
                 </ul>
         </details>
@@ -89,6 +100,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>
@@ -277,6 +289,7 @@ details {
                     <li><a href="../whatsminer/M5X#m50-vh60-stock">M50 VH60 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vh70-stock">M50 VH70 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vh80-stock">M50 VH80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh90-stock">M50 VH90 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vj10-stock">M50 VJ10 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vj20-stock">M50 VJ20 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vj30-stock">M50 VJ30 (Stock)</a></li>
@@ -295,6 +308,7 @@ details {
                     <li><a href="../whatsminer/M5X#m50s_1_1-vk10-stock">M50S++ VK10 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50s_1_1-vk20-stock">M50S++ VK20 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50s_1_1-vk30-stock">M50S++ VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s_1_1-vl30-stock">M50S++ VL30 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m53-vh30-stock">M53 VH30 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m53s-vh30-stock">M53S VH30 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m53s-vj40-stock">M53S VJ40 (Stock)</a></li>
@@ -368,6 +382,7 @@ details {
         <details>
             <summary>A11X Series:</summary>
                 <ul>
+                    <li><a href="../avalonminer/A11X#avalon-1126-pro-stock">Avalon 1126 Pro (Stock)</a></li>
                     <li><a href="../avalonminer/A11X#avalon-1166-pro-stock">Avalon 1166 Pro (Stock)</a></li>
                 </ul>
         </details>
@@ -377,6 +392,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 +415,13 @@ 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#a11-stock">A11 (Stock)</a></li>
+                    <li><a href="../innosilicon/A11X#a11mx-stock">A11MX (Stock)</a></li>
+                </ul>
+        </details>
     </ul>
 </details>
 <details>
@@ -461,6 +489,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 +497,14 @@ 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>
+        <details>
+            <summary>BMM Series:</summary>
+                <ul>
+                    <li><a href="../braiins/BMM#bmm100-bos_1">BMM100 (BOS+)</a></li>
+                    <li><a href="../braiins/BMM#bmm101-bos_1">BMM101 (BOS+)</a></li>
                 </ul>
         </details>
     </ul>
@@ -503,8 +540,11 @@ details {
                     <li><a href="../antminer/X19#s19-pro-vnish">S19 Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#s19j-vnish">S19j (VNish)</a></li>
                     <li><a href="../antminer/X19#s19j-pro-vnish">S19j Pro (VNish)</a></li>
+                    <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#s19k-pro-vnish">S19k Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#t19-vnish">T19 (VNish)</a></li>
                 </ul>
         </details>
@@ -529,12 +569,14 @@ details {
                     <li><a href="../antminer/X19#s19j-pro_1-epic">S19j Pro+ (ePIC)</a></li>
                     <li><a href="../antminer/X19#s19k-pro-epic">S19k Pro (ePIC)</a></li>
                     <li><a href="../antminer/X19#s19-xp-epic">S19 XP (ePIC)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-dual-epic">S19j Pro Dual (ePIC)</a></li>
                 </ul>
         </details>
         <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>
@@ -553,7 +595,14 @@ details {
         <details>
             <summary>X9 Series:</summary>
                 <ul>
-                    <li><a href="../antminer/X9#t9-stock">T9 (Stock)</a></li>
+                    <li><a href="../antminer/X9#t9-hive">T9 (Hive)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19j-pro-hive">S19j Pro (Hive)</a></li>
+                    <li><a href="../antminer/X19#s19-hive">S19 (Hive)</a></li>
                 </ul>
         </details>
     </ul>
@@ -647,6 +696,48 @@ details {
                     <li><a href="../bitaxe/BM#supra-stock">Supra (Stock)</a></li>
                     <li><a href="../bitaxe/BM#ultra-stock">Ultra (Stock)</a></li>
                     <li><a href="../bitaxe/BM#max-stock">Max (Stock)</a></li>
+                    <li><a href="../bitaxe/BM#gamma-stock">Gamma (Stock)</a></li>
+                </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>
+                    <li><a href="../iceriver/KSX#ks5-stock">KS5 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks5l-stock">KS5L (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks5m-stock">KS5M (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Stock Firmware Hammer Miners:</summary>
+    <ul>
+        <details>
+            <summary>DX Series:</summary>
+                <ul>
+                    <li><a href="../hammer/DX#d10-stock">D10 (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Stock Firmware Volcminers:</summary>
+    <ul>
+        <details>
+            <summary>DX Series:</summary>
+                <ul>
+                    <li><a href="../volcminer/DX#d1-stock">D1 (Stock)</a></li>
                 </ul>
         </details>
     </ul>

docs/miners/whatsminer/M2X.md

@@ -2,91 +2,169 @@
 ## M2X Models
 
 ## M20 V10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20V10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20V10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M20S V10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M20S V20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M20S V30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M20P V10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20P.BTMinerM20PV10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20P.BTMinerM20PV10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M20P V30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20P.BTMinerM20PV30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20P.BTMinerM20PV30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M20S+ V30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M20S_Plus.BTMinerM20SPlusV30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M20S_Plus.BTMinerM20SPlusV30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M21 V10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M21.BTMinerM21V10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M21.BTMinerM21V10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M21S V20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M21S V60 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV60
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV60
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M21S V70 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV70
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV70
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M21S+ V20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M21S_Plus.BTMinerM21SPlusV20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M21S_Plus.BTMinerM21SPlusV20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M29 V10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M2X.M29.BTMinerM29V10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M2X.M29.BTMinerM29V10
     handler: python
     options:
         show_root_heading: false

docs/miners/whatsminer/M5X.md

@@ -2,259 +2,507 @@
 ## M5X Models
 
 ## M50 VE30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VE30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VE30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VG30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VG30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VG30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH40
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH50 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH50
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH50
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH60 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH60
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH60
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH70 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH70
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH70
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VH80 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH80
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH80
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VH90 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH90
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VJ10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VJ20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50 VJ30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VJ10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVJ10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVJ10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VJ20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVJ20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVJ20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VJ30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVJ30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVJ30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VH10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VH20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VH40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH40
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S VH50 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH50
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S.BTMinerM50SVH50
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S+ VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S+ VH40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVH40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVH40
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S+ VJ30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVJ30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVJ30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S+ VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus.BTMinerM50SPlusVK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S++ VK10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S++ VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M50S++ VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK30
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S++ VL30 (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVL30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M53 VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M53.BTMinerM53VH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M53.BTMinerM53VH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M53S VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M53S.BTMinerM53SVH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M53S.BTMinerM53SVH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M53S VJ40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M53S.BTMinerM53SVJ40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M53S.BTMinerM53SVJ40
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M53S+ VJ30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M53S_Plus.BTMinerM53SPlusVJ30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M53S_Plus.BTMinerM53SPlusVJ30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M53S++ VK10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M53S_Plus_Plus.BTMinerM53SPlusPlusVK10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M53S_Plus_Plus.BTMinerM53SPlusPlusVK10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M56 VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M56.BTMinerM56VH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M56.BTMinerM56VH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M56S VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M56S.BTMinerM56SVH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M56S.BTMinerM56SVH30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M56S+ VJ30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M56S_Plus.BTMinerM56SPlusVJ30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M56S_Plus.BTMinerM56SPlusVJ30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M59 VH30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M5X.M59.BTMinerM59VH30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M5X.M59.BTMinerM59VH30
     handler: python
     options:
         show_root_heading: false

docs/miners/whatsminer/M6X.md

@@ -2,133 +2,247 @@
 ## M6X Models
 
 ## M60 VK10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60 VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60 VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60 VK40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60.BTMinerM60VK40
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60S VK10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60S VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60S VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M60S VK40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M60S.BTMinerM60SVK40
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M63 VK10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M63.BTMinerM63VK10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M63.BTMinerM63VK10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M63 VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M63.BTMinerM63VK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M63.BTMinerM63VK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M63 VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M63.BTMinerM63VK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M63.BTMinerM63VK30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M63S VK10 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M63S.BTMinerM63SVK10
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M63S.BTMinerM63SVK10
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M63S VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M63S.BTMinerM63SVK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M63S.BTMinerM63SVK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M63S VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M63S.BTMinerM63SVK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M63S.BTMinerM63SVK30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M66 VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M66.BTMinerM66VK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M66.BTMinerM66VK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M66 VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M66.BTMinerM66VK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M66.BTMinerM66VK30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M66S VK20 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK20
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK20
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M66S VK30 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK30
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK30
     handler: python
     options:
         show_root_heading: false
         heading_level: 4
 
 ## M66S VK40 (Stock)
-::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK40
+
+- [x] Shutdowns
+- [x] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+    ::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK40
     handler: python
     options:
         show_root_heading: false

docs/requirements.txt

@@ -1,4 +0,0 @@
-jinja2<3.1.4
-mkdocs
-mkdocstrings[python]
-zipp>=3.19.1 # not directly required, pinned by Snyk to avoid a vulnerability

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

mkdocs.yml

@@ -1,5 +1,36 @@
 site_name: pyasic
 repo_url: https://github.com/UpstreamData/pyasic
+site_url: !ENV SITE_URL
+theme:
+  name: material
+  features:
+    - content.code.copy
+    - content.code.annotate
+  palette:
+    - media: "(prefers-color-scheme)"
+      toggle:
+        icon: material/brightness-auto
+        name: Switch to light mode
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      toggle:
+        icon: material/weather-night
+        name: Switch to dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      toggle:
+        icon: material/weather-sunny
+        name: Switch to auto mode
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+  - pymdownx.superfences
 nav:
 - Introduction: "index.md"
 - Miners:
@@ -50,6 +81,8 @@ nav:
         - Antminer X17: "miners/antminer/X17.md"
         - Antminer X19: "miners/antminer/X19.md"
         - Antminer X21: "miners/antminer/X21.md"
+        - Braiins Mini Miners: "miners/braiins/BMM.md"
+        - Avalon Nano: "miners/avalonminer/nano.md"
         - Avalon 7X: "miners/avalonminer/A7X.md"
         - Avalon 8X: "miners/avalonminer/A8X.md"
         - Avalon 9X: "miners/avalonminer/A9X.md"
@@ -62,6 +95,7 @@ nav:
         - Whatsminer M6X: "miners/whatsminer/M6X.md"
         - Innosilicon T3X: "miners/innosilicon/T3X.md"
         - Innosilicon A10X: "miners/innosilicon/A10X.md"
+        - Innosilicon A11X: "miners/innosilicon/A11X.md"
         - Goldshell X5: "miners/goldshell/X5.md"
         - Goldshell XMax: "miners/goldshell/XMax.md"
         - Goldshell XBox: "miners/goldshell/XBox.md"
@@ -70,6 +104,9 @@ nav:
         - Auradine AT: "miners/auradine/AT.md"
         - Blockminer: "miners/blockminer/blockminer.md"
         - BitAxe BM: "miners/bitaxe/BM.md"
+        - Hammer DX: "miners/hammer/DX.md"
+        - Iceriver KSX: "miners/iceriver/KSX.md"
+        - Volcminer DX: "miners/volcminer/DX.md"
     - Base Miner: "miners/base_miner.md"
 - Settings:
       - Settings: "settings/settings.md"

pyasic/config/__init__.py

@@ -13,25 +13,28 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from dataclasses import asdict, dataclass, field
 
-from pyasic.config.fans import FanModeConfig
-from pyasic.config.mining import MiningModeConfig
+from pydantic import BaseModel, Field
+
+from pyasic.config.fans import FanMode, FanModeConfig, FanModeNormal
+from pyasic.config.mining import MiningMode, MiningModeConfig
 from pyasic.config.mining.scaling import ScalingConfig
 from pyasic.config.pools import PoolConfig
 from pyasic.config.temperature import TemperatureConfig
 from pyasic.misc import merge_dicts
 
 
-@dataclass
-class MinerConfig:
+class MinerConfig(BaseModel):
     """Represents the configuration for a miner including pool configuration,
     fan mode, temperature settings, mining mode, and power scaling."""
 
-    pools: PoolConfig = field(default_factory=PoolConfig.default)
-    fan_mode: FanModeConfig = field(default_factory=FanModeConfig.default)
-    temperature: TemperatureConfig = field(default_factory=TemperatureConfig.default)
-    mining_mode: MiningModeConfig = field(default_factory=MiningModeConfig.default)
+    class Config:
+        arbitrary_types_allowed = True
+
+    pools: PoolConfig = Field(default_factory=PoolConfig.default)
+    fan_mode: FanMode = Field(default_factory=FanModeConfig.default)
+    temperature: TemperatureConfig = Field(default_factory=TemperatureConfig.default)
+    mining_mode: MiningMode = Field(default_factory=MiningModeConfig.default)
 
     def __getitem__(self, item):
         try:
@@ -41,7 +44,7 @@ class MinerConfig:
 
     def as_dict(self) -> dict:
         """Converts the MinerConfig object to a dictionary."""
-        return asdict(self)
+        return self.model_dump()
 
     def as_am_modern(self, user_suffix: str = None) -> dict:
         """Generates the configuration in the format suitable for modern Antminers."""
@@ -107,7 +110,7 @@ class MinerConfig:
         }
 
     def as_boser(self, user_suffix: str = None) -> dict:
-        """ "Generates the configuration in the format suitable for BOSer."""
+        """Generates the configuration in the format suitable for BOSer."""
         return {
             **self.fan_mode.as_boser(),
             **self.temperature.as_boser(),
@@ -148,6 +151,30 @@ class MinerConfig:
             **self.pools.as_bitaxe(user_suffix=user_suffix),
         }
 
+    def as_luxos(self, user_suffix: str = None) -> dict:
+        return {
+            **self.fan_mode.as_luxos(),
+            **self.temperature.as_luxos(),
+            **self.mining_mode.as_luxos(),
+            **self.pools.as_luxos(user_suffix=user_suffix),
+        }
+
+    def as_vnish(self, user_suffix: str = None) -> dict:
+        main_cfg = {
+            "miner": {
+                **self.fan_mode.as_vnish(),
+                **self.temperature.as_vnish(),
+                **self.mining_mode.as_vnish(),
+                **self.pools.as_vnish(user_suffix=user_suffix),
+            }
+        }
+        if isinstance(self.fan_mode, FanModeNormal):
+            main_cfg["miner"]["cooling"]["mode"]["param"] = self.temperature.target
+        return main_cfg
+
+    def as_hammer(self, *args, **kwargs) -> dict:
+        return self.as_am_modern(*args, **kwargs)
+
     @classmethod
     def from_dict(cls, dict_conf: dict) -> "MinerConfig":
         """Constructs a MinerConfig object from a dictionary."""
@@ -218,13 +245,13 @@ class MinerConfig:
         )
 
     @classmethod
-    def from_vnish(cls, web_settings: dict) -> "MinerConfig":
+    def from_vnish(cls, web_settings: dict, web_presets: list[dict]) -> "MinerConfig":
         """Constructs a MinerConfig object from web settings for VNish miners."""
         return cls(
             pools=PoolConfig.from_vnish(web_settings),
             fan_mode=FanModeConfig.from_vnish(web_settings),
             temperature=TemperatureConfig.from_vnish(web_settings),
-            mining_mode=MiningModeConfig.from_vnish(web_settings),
+            mining_mode=MiningModeConfig.from_vnish(web_settings, web_presets),
         )
 
     @classmethod
@@ -250,3 +277,38 @@ class MinerConfig:
             pools=PoolConfig.from_bitaxe(web_system_info),
             fan_mode=FanModeConfig.from_bitaxe(web_system_info),
         )
+
+    @classmethod
+    def from_iceriver(cls, web_userpanel: dict) -> "MinerConfig":
+        return cls(
+            pools=PoolConfig.from_iceriver(web_userpanel),
+        )
+
+    @classmethod
+    def from_luxos(
+        cls,
+        rpc_tempctrl: dict,
+        rpc_fans: dict,
+        rpc_pools: dict,
+        rpc_groups: dict,
+        rpc_config: dict,
+        rpc_profiles: dict,
+    ) -> "MinerConfig":
+        return cls(
+            temperature=TemperatureConfig.from_luxos(rpc_tempctrl=rpc_tempctrl),
+            fan_mode=FanModeConfig.from_luxos(
+                rpc_tempctrl=rpc_tempctrl, rpc_fans=rpc_fans
+            ),
+            pools=PoolConfig.from_luxos(rpc_pools=rpc_pools, rpc_groups=rpc_groups),
+            mining_mode=MiningModeConfig.from_luxos(
+                rpc_config=rpc_config, rpc_profiles=rpc_profiles
+            ),
+        )
+
+    @classmethod
+    def from_hammer(cls, *args, **kwargs) -> "MinerConfig":
+        return cls.from_am_modern(*args, **kwargs)
+
+    @classmethod
+    def from_hiveon_modern(cls, web_conf: dict) -> "MinerConfig":
+        return cls.from_am_modern(web_conf)

pyasic/config/base.py

@@ -15,9 +15,10 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
 from enum import Enum
 
+from pydantic import BaseModel
+
 
 class MinerConfigOption(Enum):
     @classmethod
@@ -63,6 +64,9 @@ class MinerConfigOption(Enum):
     def as_bitaxe(self) -> dict:
         return self.value.as_bitaxe()
 
+    def as_luxos(self) -> dict:
+        return self.value.as_luxos()
+
     def __call__(self, *args, **kwargs):
         return self.value(*args, **kwargs)
 
@@ -77,14 +81,13 @@ class MinerConfigOption(Enum):
             raise KeyError
 
 
-@dataclass
-class MinerConfigValue:
+class MinerConfigValue(BaseModel):
     @classmethod
     def from_dict(cls, dict_conf: dict | None):
         return cls()
 
     def as_dict(self) -> dict:
-        return asdict(self)
+        return self.model_dump()
 
     def as_am_modern(self) -> dict:
         return {}
@@ -125,6 +128,9 @@ class MinerConfigValue:
     def as_bitaxe(self) -> dict:
         return {}
 
+    def as_luxos(self) -> dict:
+        return {}
+
     def __getitem__(self, item):
         try:
             return getattr(self, item)

pyasic/config/fans.py

@@ -15,14 +15,15 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from typing import TypeVar, Union
+
+from pydantic import Field
 
 from pyasic.config.base import MinerConfigOption, MinerConfigValue
 
 
-@dataclass
 class FanModeNormal(MinerConfigValue):
-    mode: str = field(init=False, default="normal")
+    mode: str = Field(init=False, default="normal")
     minimum_fans: int = 1
     minimum_speed: int = 0
 
@@ -83,10 +84,24 @@ class FanModeNormal(MinerConfigValue):
     def as_bitaxe(self) -> dict:
         return {"autoFanspeed": 1}
 
+    def as_luxos(self) -> dict:
+        return {"fanset": {"speed": -1, "min_fans": self.minimum_fans}}
+
+    def as_vnish(self) -> dict:
+        return {
+            "cooling": {
+                "fan_min_count": self.minimum_fans,
+                "fan_min_duty": self.minimum_speed,
+                "mode": {
+                    "name": "auto",
+                    "param": None,  # Target temp, must be set later...
+                },
+            }
+        }
+
 
-@dataclass
 class FanModeManual(MinerConfigValue):
-    mode: str = field(init=False, default="manual")
+    mode: str = Field(init=False, default="manual")
     speed: int = 100
     minimum_fans: int = 1
 
@@ -144,10 +159,24 @@ class FanModeManual(MinerConfigValue):
     def as_bitaxe(self) -> dict:
         return {"autoFanspeed": 0, "fanspeed": self.speed}
 
+    def as_luxos(self) -> dict:
+        return {"fanset": {"speed": self.speed, "min_fans": self.minimum_fans}}
+
+    def as_vnish(self) -> dict:
+        return {
+            "cooling": {
+                "fan_min_count": self.minimum_fans,
+                "fan_min_duty": self.speed,
+                "mode": {
+                    "name": "manual",
+                    "param": self.speed,  # Speed value
+                },
+            }
+        }
+
 
-@dataclass
 class FanModeImmersion(MinerConfigValue):
-    mode: str = field(init=False, default="immersion")
+    mode: str = Field(init=False, default="immersion")
 
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "FanModeImmersion":
@@ -167,6 +196,12 @@ class FanModeImmersion(MinerConfigValue):
     def as_mara(self) -> dict:
         return {"general-config": {"environment-profile": "OilImmersionCooling"}}
 
+    def as_luxos(self) -> dict:
+        return {"fanset": {"speed": 0, "min_fans": 0}}
+
+    def as_vnish(self) -> dict:
+        return {"cooling": {"mode": {"name": "immers"}}}
+
 
 class FanModeConfig(MinerConfigOption):
     normal = FanModeNormal
@@ -264,7 +299,7 @@ class FanModeConfig(MinerConfigOption):
         keys = temperature_conf.keys()
         if "auto" in keys:
             if "minimumRequiredFans" in keys:
-                return cls.normal(temperature_conf["minimumRequiredFans"])
+                return cls.normal(minimum_fans=temperature_conf["minimumRequiredFans"])
             return cls.normal()
         if "manual" in keys:
             conf = {}
@@ -291,7 +326,9 @@ class FanModeConfig(MinerConfigOption):
             mode = web_config["general-config"]["environment-profile"]
             if mode == "AirCooling":
                 if web_config["advance-config"]["override-fan-control"]:
-                    return cls.manual(web_config["advance-config"]["fan-fixed-percent"])
+                    return cls.manual(
+                        speed=web_config["advance-config"]["fan-fixed-percent"]
+                    )
                 return cls.normal()
             return cls.immersion()
         except LookupError:
@@ -304,3 +341,29 @@ class FanModeConfig(MinerConfigOption):
             return cls.normal()
         else:
             return cls.manual(speed=web_system_info["fanspeed"])
+
+    @classmethod
+    def from_luxos(cls, rpc_fans: dict, rpc_tempctrl: dict):
+        try:
+            mode = rpc_tempctrl["TEMPCTRL"][0]["Mode"]
+            if mode == "Manual":
+                speed = rpc_fans["FANS"][0]["Speed"]
+                min_fans = rpc_fans["FANCTRL"][0]["MinFans"]
+                if min_fans == 0 and speed == 0:
+                    return cls.immersion()
+                return cls.manual(
+                    speed=speed,
+                    minimum_fans=min_fans,
+                )
+            return cls.normal(
+                minimum_fans=rpc_fans["FANCTRL"][0]["MinFans"],
+            )
+        except LookupError:
+            pass
+        return cls.default()
+
+
+FanMode = TypeVar(
+    "FanMode",
+    bound=Union[FanModeNormal, FanModeManual, FanModeImmersion],
+)

pyasic/config/mining/__init__.py

@@ -15,7 +15,8 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import field
+from typing import TypeVar, Union
 
 from pyasic import settings
 from pyasic.config.base import MinerConfigOption, MinerConfigValue
@@ -34,11 +35,11 @@ from pyasic.web.braiins_os.proto.braiins.bos.v1 import (
     TunerPerformanceMode,
 )
 
-from .algo import TunerAlgo
+from .algo import TunerAlgo, TunerAlgoType
+from .presets import MiningPreset
 from .scaling import ScalingConfig
 
 
-@dataclass
 class MiningModeNormal(MinerConfigValue):
     mode: str = field(init=False, default="normal")
 
@@ -70,8 +71,10 @@ class MiningModeNormal(MinerConfigValue):
             }
         }
 
+    def as_luxos(self) -> dict:
+        return {"autotunerset": {"enabled": False}}
+
 
-@dataclass
 class MiningModeSleep(MinerConfigValue):
     mode: str = field(init=False, default="sleep")
 
@@ -104,7 +107,6 @@ class MiningModeSleep(MinerConfigValue):
         }
 
 
-@dataclass
 class MiningModeLPM(MinerConfigValue):
     mode: str = field(init=False, default="low")
 
@@ -127,7 +129,6 @@ class MiningModeLPM(MinerConfigValue):
         return {"settings": {"level": 1}}
 
 
-@dataclass
 class MiningModeHPM(MinerConfigValue):
     mode: str = field(init=False, default="high")
 
@@ -147,12 +148,14 @@ class MiningModeHPM(MinerConfigValue):
         return {"mode": {"mode": "turbo"}}
 
 
-@dataclass
 class MiningModePowerTune(MinerConfigValue):
+    class Config:
+        arbitrary_types_allowed = True
+
     mode: str = field(init=False, default="power_tuning")
-    power: int = None
-    algo: TunerAlgo = field(default_factory=TunerAlgo.default)
-    scaling: ScalingConfig = None
+    power: int | None = None
+    algo: TunerAlgoType = field(default_factory=TunerAlgo.default)
+    scaling: ScalingConfig | None = None
 
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "MiningModePowerTune":
@@ -198,7 +201,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(
@@ -240,13 +243,18 @@ class MiningModePowerTune(MinerConfigValue):
             }
         }
 
+    def as_luxos(self) -> dict:
+        return {"autotunerset": {"enabled": True}}
+
 
-@dataclass
 class MiningModeHashrateTune(MinerConfigValue):
+    class Config:
+        arbitrary_types_allowed = True
+
     mode: str = field(init=False, default="hashrate_tuning")
-    hashrate: int = None
-    algo: TunerAlgo = field(default_factory=TunerAlgo.default)
-    scaling: ScalingConfig = None
+    hashrate: int | None = None
+    algo: TunerAlgoType = field(default_factory=TunerAlgo.default)
+    scaling: ScalingConfig | None = None
 
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "MiningModeHashrateTune":
@@ -275,7 +283,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(
@@ -333,8 +341,49 @@ class MiningModeHashrateTune(MinerConfigValue):
             }
         }
 
+    def as_luxos(self) -> dict:
+        return {"autotunerset": {"enabled": True}}
+
+
+class MiningModePreset(MinerConfigValue):
+    mode: str = field(init=False, default="preset")
+
+    active_preset: MiningPreset
+    available_presets: list[MiningPreset] = field(default_factory=list)
+
+    def as_vnish(self) -> dict:
+        return {"overclock": {**self.active_preset.as_vnish()}}
+
+    @classmethod
+    def from_vnish(
+        cls, web_overclock_settings: dict, web_presets: list[dict]
+    ) -> "MiningModePreset":
+        active_preset = None
+        for preset in web_presets:
+            if preset["name"] == web_overclock_settings["preset"]:
+                active_preset = preset
+        return cls(
+            active_preset=MiningPreset.from_vnish(active_preset),
+            available_presets=[MiningPreset.from_vnish(p) for p in web_presets],
+        )
+
+    @classmethod
+    def from_luxos(
+        cls, rpc_config: dict, rpc_profiles: list[dict]
+    ) -> "MiningModePreset":
+        active_preset = None
+        active_profile = rpc_config["CONFIG"][0]["Profile"]
+        for profile in rpc_profiles["PROFILES"]:
+            if profile["Profile Name"] == active_profile:
+                active_preset = profile
+        return cls(
+            active_preset=MiningPreset.from_luxos(active_preset),
+            available_presets=[
+                MiningPreset.from_luxos(p) for p in rpc_profiles["PROFILES"]
+            ],
+        )
+
 
-@dataclass
 class ManualBoardSettings(MinerConfigValue):
     freq: float
     volt: float
@@ -348,8 +397,10 @@ class ManualBoardSettings(MinerConfigValue):
             return {"miner-mode": "0"}
         return {"miner-mode": 0}
 
+    def as_vnish(self) -> dict:
+        return {"freq": self.freq}
+
 
-@dataclass
 class MiningModeManual(MinerConfigValue):
     mode: str = field(init=False, default="manual")
 
@@ -370,6 +421,18 @@ class MiningModeManual(MinerConfigValue):
             return {"miner-mode": "0"}
         return {"miner-mode": 0}
 
+    def as_vnish(self) -> dict:
+        chains = [b.as_vnish() for b in self.boards.values() if b.freq != 0]
+        return {
+            "overclock": {
+                "chains": chains if chains != [] else None,
+                "globals": {
+                    "freq": int(self.global_freq),
+                    "volt": int(self.global_volt),
+                },
+            }
+        }
+
     @classmethod
     def from_vnish(cls, web_overclock_settings: dict) -> "MiningModeManual":
         # will raise KeyError if it cant find the settings, values cannot be empty
@@ -421,6 +484,7 @@ class MiningModeConfig(MinerConfigOption):
     sleep = MiningModeSleep
     power_tuning = MiningModePowerTune
     hashrate_tuning = MiningModeHashrateTune
+    preset = MiningModePreset
     manual = MiningModeManual
 
     @classmethod
@@ -512,7 +576,7 @@ class MiningModeConfig(MinerConfigOption):
         if autotuning_conf.get("psu_power_limit") is not None:
             # old autotuning conf
             return cls.power_tuning(
-                autotuning_conf["psu_power_limit"],
+                power=autotuning_conf["psu_power_limit"],
                 scaling=ScalingConfig.from_bosminer(toml_conf, mode="power"),
             )
         if autotuning_conf.get("mode") is not None:
@@ -521,7 +585,7 @@ class MiningModeConfig(MinerConfigOption):
             if mode == "power_target":
                 if autotuning_conf.get("power_target") is not None:
                     return cls.power_tuning(
-                        autotuning_conf["power_target"],
+                        power=autotuning_conf["power_target"],
                         scaling=ScalingConfig.from_bosminer(toml_conf, mode="power"),
                     )
                 return cls.power_tuning(
@@ -530,7 +594,7 @@ class MiningModeConfig(MinerConfigOption):
             if mode == "hashrate_target":
                 if autotuning_conf.get("hashrate_target") is not None:
                     return cls.hashrate_tuning(
-                        autotuning_conf["hashrate_target"],
+                        hashrate=autotuning_conf["hashrate_target"],
                         scaling=ScalingConfig.from_bosminer(toml_conf, mode="hashrate"),
                     )
                 return cls.hashrate_tuning(
@@ -538,7 +602,7 @@ class MiningModeConfig(MinerConfigOption):
                 )
 
     @classmethod
-    def from_vnish(cls, web_settings: dict):
+    def from_vnish(cls, web_settings: dict, web_presets: list[dict]):
         try:
             mode_settings = web_settings["miner"]["overclock"]
         except KeyError:
@@ -547,7 +611,7 @@ class MiningModeConfig(MinerConfigOption):
         if mode_settings["preset"] == "disabled":
             return MiningModeManual.from_vnish(mode_settings)
         else:
-            return cls.power_tuning(int(mode_settings["preset"]))
+            return MiningModePreset.from_vnish(mode_settings, web_presets)
 
     @classmethod
     def from_boser(cls, grpc_miner_conf: dict):
@@ -562,7 +626,7 @@ class MiningModeConfig(MinerConfigOption):
             if tuner_conf["tunerMode"] == 1:
                 if tuner_conf.get("powerTarget") is not None:
                     return cls.power_tuning(
-                        tuner_conf["powerTarget"]["watt"],
+                        power=tuner_conf["powerTarget"]["watt"],
                         scaling=ScalingConfig.from_boser(grpc_miner_conf, mode="power"),
                     )
                 return cls.power_tuning(
@@ -572,7 +636,7 @@ class MiningModeConfig(MinerConfigOption):
             if tuner_conf["tunerMode"] == 2:
                 if tuner_conf.get("hashrateTarget") is not None:
                     return cls.hashrate_tuning(
-                        int(tuner_conf["hashrateTarget"]["terahashPerSecond"]),
+                        hashrate=int(tuner_conf["hashrateTarget"]["terahashPerSecond"]),
                         scaling=ScalingConfig.from_boser(
                             grpc_miner_conf, mode="hashrate"
                         ),
@@ -583,16 +647,18 @@ class MiningModeConfig(MinerConfigOption):
 
         if tuner_conf.get("powerTarget") is not None:
             return cls.power_tuning(
-                tuner_conf["powerTarget"]["watt"],
+                power=tuner_conf["powerTarget"]["watt"],
                 scaling=ScalingConfig.from_boser(grpc_miner_conf, mode="power"),
             )
 
         if tuner_conf.get("hashrateTarget") is not None:
             return cls.hashrate_tuning(
-                int(tuner_conf["hashrateTarget"]["terahashPerSecond"]),
+                hashrate=int(tuner_conf["hashrateTarget"]["terahashPerSecond"]),
                 scaling=ScalingConfig.from_boser(grpc_miner_conf, mode="hashrate"),
             )
 
+        return cls.default()
+
     @classmethod
     def from_auradine(cls, web_mode: dict):
         try:
@@ -606,9 +672,9 @@ class MiningModeConfig(MinerConfigOption):
             if mode_data.get("Mode") == "turbo":
                 return cls.high()
             if mode_data.get("Ths") is not None:
-                return cls.hashrate_tuning(mode_data["Ths"])
+                return cls.hashrate_tuning(hashrate=mode_data["Ths"])
             if mode_data.get("Power") is not None:
-                return cls.power_tuning(mode_data["Power"])
+                return cls.power_tuning(power=mode_data["Power"])
         except LookupError:
             return cls.default()
 
@@ -636,3 +702,22 @@ class MiningModeConfig(MinerConfigOption):
         except LookupError:
             pass
         return cls.default()
+
+    @classmethod
+    def from_luxos(cls, rpc_config: dict, rpc_profiles: dict):
+        return MiningModePreset.from_luxos(rpc_config, rpc_profiles)
+
+
+MiningMode = TypeVar(
+    "MiningMode",
+    bound=Union[
+        MiningModeNormal,
+        MiningModeHPM,
+        MiningModeLPM,
+        MiningModeSleep,
+        MiningModeManual,
+        MiningModePowerTune,
+        MiningModeHashrateTune,
+        MiningModePreset,
+    ],
+)

pyasic/config/mining/algo.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from typing import TypeVar, Union
 
 from pyasic.config.base import MinerConfigOption, MinerConfigValue
 
 
-@dataclass
 class StandardTuneAlgo(MinerConfigValue):
     mode: str = field(init=False, default="standard")
 
@@ -13,7 +13,6 @@ class StandardTuneAlgo(MinerConfigValue):
         return VOptAlgo().as_epic()
 
 
-@dataclass
 class VOptAlgo(MinerConfigValue):
     mode: str = field(init=False, default="voltage_optimizer")
 
@@ -21,7 +20,6 @@ class VOptAlgo(MinerConfigValue):
         return "VoltageOptimizer"
 
 
-@dataclass
 class BoardTuneAlgo(MinerConfigValue):
     mode: str = field(init=False, default="board_tune")
 
@@ -29,7 +27,6 @@ class BoardTuneAlgo(MinerConfigValue):
         return "BoardTune"
 
 
-@dataclass
 class ChipTuneAlgo(MinerConfigValue):
     mode: str = field(init=False, default="chip_tune")
 
@@ -37,7 +34,6 @@ class ChipTuneAlgo(MinerConfigValue):
         return "ChipTune"
 
 
-@dataclass
 class TunerAlgo(MinerConfigOption):
     standard = StandardTuneAlgo
     voltage_optimizer = VOptAlgo
@@ -45,11 +41,11 @@ class TunerAlgo(MinerConfigOption):
     chip_tune = ChipTuneAlgo
 
     @classmethod
-    def default(cls):
+    def default(cls) -> TunerAlgoType:
         return cls.standard()
 
     @classmethod
-    def from_dict(cls, dict_conf: dict | None):
+    def from_dict(cls, dict_conf: dict | None) -> TunerAlgoType:
         mode = dict_conf.get("mode")
         if mode is None:
             return cls.default()
@@ -57,3 +53,14 @@ class TunerAlgo(MinerConfigOption):
         cls_attr = getattr(cls, mode)
         if cls_attr is not None:
             return cls_attr().from_dict(dict_conf)
+
+
+TunerAlgoType = TypeVar(
+    "TunerAlgoType",
+    bound=Union[
+        StandardTuneAlgo,
+        VOptAlgo,
+        BoardTuneAlgo,
+        ChipTuneAlgo,
+    ],
+)

pyasic/config/mining/presets.py

@@ -0,0 +1,47 @@
+from pyasic.config.base import MinerConfigValue
+
+
+class MiningPreset(MinerConfigValue):
+    name: str | None = None
+    power: int | None = None
+    hashrate: int | None = None
+    tuned: bool | None = None
+    modded_psu: bool | None = None
+    frequency: int | None = None
+    voltage: float | None = None
+
+    def as_vnish(self) -> dict:
+        if self.name is not None:
+            return {"preset": self.name}
+        return {}
+
+    @classmethod
+    def from_vnish(cls, web_preset: dict):
+        name = web_preset["name"]
+        hr_power_split = web_preset["pretty"].split("~")
+        if len(hr_power_split) == 1:
+            power = None
+            hashrate = None
+        else:
+            power = hr_power_split[0].replace("watt", "").strip()
+            hashrate = hr_power_split[1].replace("TH", "").replace(" LC", "").strip()
+        tuned = web_preset["status"] == "tuned"
+        modded_psu = web_preset["modded_psu_required"]
+        return cls(
+            name=name,
+            power=power,
+            hashrate=hashrate,
+            tuned=tuned,
+            modded_psu=modded_psu,
+        )
+
+    @classmethod
+    def from_luxos(cls, profile: dict):
+        return cls(
+            name=profile["Profile Name"],
+            power=profile["Watts"],
+            hashrate=round(profile["Hashrate"]),
+            tuned=profile["IsTuned"],
+            frequency=profile["Frequency"],
+            voltage=profile["Voltage"],
+        )

pyasic/config/mining/scaling.py

@@ -20,7 +20,6 @@ from dataclasses import dataclass
 from pyasic.config.base import MinerConfigValue
 
 
-@dataclass
 class ScalingShutdown(MinerConfigValue):
     enabled: bool = False
     duration: int = None
@@ -35,7 +34,9 @@ class ScalingShutdown(MinerConfigValue):
     def from_bosminer(cls, power_scaling_conf: dict):
         sd_enabled = power_scaling_conf.get("shutdown_enabled")
         if sd_enabled is not None:
-            return cls(sd_enabled, power_scaling_conf.get("shutdown_duration"))
+            return cls(
+                enabled=sd_enabled, duration=power_scaling_conf.get("shutdown_duration")
+            )
         return None
 
     @classmethod
@@ -43,9 +44,12 @@ class ScalingShutdown(MinerConfigValue):
         sd_enabled = power_scaling_conf.get("shutdownEnabled")
         if sd_enabled is not None:
             try:
-                return cls(sd_enabled, power_scaling_conf["shutdownDuration"]["hours"])
+                return cls(
+                    enabled=sd_enabled,
+                    duration=power_scaling_conf["shutdownDuration"]["hours"],
+                )
             except KeyError:
-                return cls(sd_enabled)
+                return cls(enabled=sd_enabled)
         return None
 
     def as_bosminer(self) -> dict:
@@ -60,7 +64,6 @@ class ScalingShutdown(MinerConfigValue):
         return {"enable_shutdown": self.enabled, "shutdown_duration": self.duration}
 
 
-@dataclass
 class ScalingConfig(MinerConfigValue):
     step: int = None
     minimum: int = None

pyasic/config/pools.py

@@ -17,9 +17,10 @@ from __future__ import annotations
 
 import random
 import string
-from dataclasses import dataclass, field
 from typing import List
 
+from pydantic import Field
+
 from pyasic.config.base import MinerConfigValue
 from pyasic.web.braiins_os.proto.braiins.bos.v1 import (
     PoolConfiguration,
@@ -30,122 +31,99 @@ from pyasic.web.braiins_os.proto.braiins.bos.v1 import (
 )
 
 
-@dataclass
 class Pool(MinerConfigValue):
     url: str
     user: str
     password: str
 
-    def as_am_modern(self, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                "url": self.url,
-                "user": f"{self.user}{user_suffix}",
-                "pass": self.password,
-            }
-        return {"url": self.url, "user": self.user, "pass": self.password}
+    def as_am_modern(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "pass": self.password,
+        }
 
-    def as_wm(self, idx: int = 1, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                f"pool_{idx}": self.url,
-                f"worker_{idx}": f"{self.user}{user_suffix}",
-                f"passwd_{idx}": self.password,
-            }
+    def as_wm(self, idx: int = 1, user_suffix: str | None = None) -> dict:
         return {
             f"pool_{idx}": self.url,
-            f"worker_{idx}": self.user,
+            f"worker_{idx}": f"{self.user}{user_suffix or ''}",
             f"passwd_{idx}": self.password,
         }
 
-    def as_am_old(self, idx: int = 1, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                f"_ant_pool{idx}url": self.url,
-                f"_ant_pool{idx}user": f"{self.user}{user_suffix}",
-                f"_ant_pool{idx}pw": self.password,
-            }
+    def as_am_old(self, idx: int = 1, user_suffix: str | None = None) -> dict:
         return {
             f"_ant_pool{idx}url": self.url,
-            f"_ant_pool{idx}user": self.user,
+            f"_ant_pool{idx}user": f"{self.user}{user_suffix or ''}",
             f"_ant_pool{idx}pw": self.password,
         }
 
-    def as_goldshell(self, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                "url": self.url,
-                "user": f"{self.user}{user_suffix}",
-                "pass": self.password,
-            }
-        return {"url": self.url, "user": self.user, "pass": self.password}
+    def as_goldshell(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "pass": self.password,
+        }
 
-    def as_avalon(self, user_suffix: str = None) -> str:
-        if user_suffix is not None:
-            return ",".join([self.url, f"{self.user}{user_suffix}", self.password])
-        return ",".join([self.url, self.user, self.password])
+    def as_avalon(self, user_suffix: str | None = None) -> str:
+        return ",".join([self.url, f"{self.user}{user_suffix or ''}", self.password])
 
-    def as_inno(self, idx: int = 1, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                f"Pool{idx}": self.url,
-                f"UserName{idx}": f"{self.user}{user_suffix}",
-                f"Password{idx}": self.password,
-            }
+    def as_inno(self, idx: int = 1, user_suffix: str | None = None) -> dict:
         return {
             f"Pool{idx}": self.url,
-            f"UserName{idx}": self.user,
+            f"UserName{idx}": f"{self.user}{user_suffix or ''}",
             f"Password{idx}": self.password,
         }
 
-    def as_bosminer(self, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                "url": self.url,
-                "user": f"{self.user}{user_suffix}",
-                "password": self.password,
-            }
-        return {"url": self.url, "user": self.user, "password": self.password}
+    def as_bosminer(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "password": self.password,
+        }
 
-    def as_auradine(self, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                "url": self.url,
-                "user": f"{self.user}{user_suffix}",
-                "pass": self.password,
-            }
-        return {"url": self.url, "user": self.user, "pass": self.password}
+    def as_auradine(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "pass": self.password,
+        }
 
-    def as_epic(self, user_suffix: str = None):
-        if user_suffix is not None:
-            return {
-                "pool": self.url,
-                "login": f"{self.user}{user_suffix}",
-                "password": self.password,
-            }
-        return {"pool": self.url, "login": self.user, "password": self.password}
+    def as_epic(self, user_suffix: str | None = None):
+        return {
+            "pool": self.url,
+            "login": f"{self.user}{user_suffix or ''}",
+            "password": self.password,
+        }
 
-    def as_mara(self, user_suffix: str = None) -> dict:
-        if user_suffix is not None:
-            return {
-                "url": self.url,
-                "user": f"{self.user}{user_suffix}",
-                "pass": self.password,
-            }
-        return {"url": self.url, "user": self.user, "pass": self.password}
+    def as_mara(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "pass": self.password,
+        }
 
-    def as_bitaxe(self, user_suffix: str = None) -> dict:
+    def as_bitaxe(self, user_suffix: str | None = None) -> dict:
         return {
             "stratumURL": self.url,
-            "stratumUser": f"{self.user}{user_suffix}",
+            "stratumUser": f"{self.user}{user_suffix or ''}",
             "stratumPassword": self.password,
         }
 
-    def as_boser(self) -> PoolConfiguration:
+    def as_boser(self, user_suffix: str | None = None) -> PoolConfiguration:
         return PoolConfiguration(
-            url=self.url, user=self.user, password=self.password, enabled=True
+            url=self.url,
+            user=f"{self.user}{user_suffix or ''}",
+            password=self.password,
+            enabled=True,
         )
 
+    def as_vnish(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "pass": self.password,
+        }
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "Pool":
         return cls(
@@ -192,7 +170,7 @@ class Pool(MinerConfigValue):
     @classmethod
     def from_vnish(cls, web_pool: dict) -> "Pool":
         return cls(
-            url=web_pool["url"],
+            url="stratum+tcp://" + web_pool["url"],
             user=web_pool["user"],
             password=web_pool["pass"],
         )
@@ -222,12 +200,23 @@ class Pool(MinerConfigValue):
             password=web_system_info.get("stratumPassword", ""),
         )
 
+    @classmethod
+    def from_luxos(cls, rpc_pools: dict) -> "Pool":
+        return cls.from_api(rpc_pools)
+
+    @classmethod
+    def from_iceriver(cls, web_pool: dict) -> "Pool":
+        return cls(
+            url=web_pool["addr"],
+            user=web_pool["user"],
+            password=web_pool["pass"],
+        )
+
 
-@dataclass
 class PoolGroup(MinerConfigValue):
-    pools: list[Pool] = field(default_factory=list)
+    pools: list[Pool] = Field(default_factory=list)
     quota: int = 1
-    name: str = None
+    name: str | None = None
 
     def __post_init__(self):
         if self.name is None:
@@ -235,18 +224,18 @@ class PoolGroup(MinerConfigValue):
                 random.choice(string.ascii_uppercase + string.digits) for _ in range(6)
             )  # generate random pool group name in case it isn't set
 
-    def as_am_modern(self, user_suffix: str = None) -> list:
+    def as_am_modern(self, user_suffix: str | None = None) -> list:
         pools = []
         idx = 0
         while idx < 3:
             if len(self.pools) > idx:
                 pools.append(self.pools[idx].as_am_modern(user_suffix=user_suffix))
             else:
-                pools.append(Pool("", "", "").as_am_modern())
+                pools.append(Pool(url="", user="", password="").as_am_modern())
             idx += 1
         return pools
 
-    def as_wm(self, user_suffix: str = None) -> dict:
+    def as_wm(self, user_suffix: str | None = None) -> dict:
         pools = {}
         idx = 0
         while idx < 3:
@@ -255,11 +244,11 @@ class PoolGroup(MinerConfigValue):
                     **self.pools[idx].as_wm(idx=idx + 1, user_suffix=user_suffix)
                 )
             else:
-                pools.update(**Pool("", "", "").as_wm(idx=idx + 1))
+                pools.update(**Pool(url="", user="", password="").as_wm(idx=idx + 1))
             idx += 1
         return pools
 
-    def as_am_old(self, user_suffix: str = None) -> dict:
+    def as_am_old(self, user_suffix: str | None = None) -> dict:
         pools = {}
         idx = 0
         while idx < 3:
@@ -268,19 +257,21 @@ class PoolGroup(MinerConfigValue):
                     **self.pools[idx].as_am_old(idx=idx + 1, user_suffix=user_suffix)
                 )
             else:
-                pools.update(**Pool("", "", "").as_am_old(idx=idx + 1))
+                pools.update(
+                    **Pool(url="", user="", password="").as_am_old(idx=idx + 1)
+                )
             idx += 1
         return pools
 
-    def as_goldshell(self, user_suffix: str = None) -> list:
+    def as_goldshell(self, user_suffix: str | None = None) -> list:
         return [pool.as_goldshell(user_suffix) for pool in self.pools]
 
-    def as_avalon(self, user_suffix: str = None) -> str:
+    def as_avalon(self, user_suffix: str | None = None) -> str:
         if len(self.pools) > 0:
             return self.pools[0].as_avalon(user_suffix=user_suffix)
-        return Pool("", "", "").as_avalon()
+        return Pool(url="", user="", password="").as_avalon()
 
-    def as_inno(self, user_suffix: str = None) -> dict:
+    def as_inno(self, user_suffix: str | None = None) -> dict:
         pools = {}
         idx = 0
         while idx < 3:
@@ -289,11 +280,11 @@ class PoolGroup(MinerConfigValue):
                     **self.pools[idx].as_inno(idx=idx + 1, user_suffix=user_suffix)
                 )
             else:
-                pools.update(**Pool("", "", "").as_inno(idx=idx + 1))
+                pools.update(**Pool(url="", user="", password="").as_inno(idx=idx + 1))
             idx += 1
         return pools
 
-    def as_bosminer(self, user_suffix: str = None) -> dict:
+    def as_bosminer(self, user_suffix: str | None = None) -> dict:
         if len(self.pools) > 0:
             conf = {
                 "name": self.name,
@@ -306,25 +297,28 @@ class PoolGroup(MinerConfigValue):
             return conf
         return {"name": "Group", "pool": []}
 
-    def as_auradine(self, user_suffix: str = None) -> list:
+    def as_auradine(self, user_suffix: str | None = None) -> list:
         return [p.as_auradine(user_suffix=user_suffix) for p in self.pools]
 
-    def as_epic(self, user_suffix: str = None) -> list:
+    def as_epic(self, user_suffix: str | None = None) -> list:
         return [p.as_epic(user_suffix=user_suffix) for p in self.pools]
 
-    def as_mara(self, user_suffix: str = None) -> list:
+    def as_mara(self, user_suffix: str | None = None) -> list:
         return [p.as_mara(user_suffix=user_suffix) for p in self.pools]
 
-    def as_bitaxe(self, user_suffix: str = None) -> dict:
+    def as_bitaxe(self, user_suffix: str | None = None) -> dict:
         return self.pools[0].as_bitaxe(user_suffix=user_suffix)
 
-    def as_boser(self, user_suffix: str = None) -> PoolGroupConfiguration:
+    def as_boser(self, user_suffix: str | None = None) -> PoolGroupConfiguration:
         return PoolGroupConfiguration(
             name=self.name,
             quota=Quota(value=self.quota),
             pools=[p.as_boser() for p in self.pools],
         )
 
+    def as_vnish(self, user_suffix: str | None = None) -> dict:
+        return {"pools": [p.as_vnish(user_suffix=user_suffix) for p in self.pools]}
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "PoolGroup":
         cls_conf = {}
@@ -359,11 +353,11 @@ class PoolGroup(MinerConfigValue):
 
     @classmethod
     def from_goldshell(cls, web_pools: list) -> "PoolGroup":
-        return cls([Pool.from_goldshell(p) for p in web_pools])
+        return cls(pools=[Pool.from_goldshell(p) for p in web_pools])
 
     @classmethod
     def from_inno(cls, web_pools: list) -> "PoolGroup":
-        return cls([Pool.from_inno(p) for p in web_pools])
+        return cls(pools=[Pool.from_inno(p) for p in web_pools])
 
     @classmethod
     def from_bosminer(cls, toml_group_conf: dict) -> "PoolGroup":
@@ -377,7 +371,9 @@ class PoolGroup(MinerConfigValue):
 
     @classmethod
     def from_vnish(cls, web_settings_pools: dict) -> "PoolGroup":
-        return cls([Pool.from_vnish(p) for p in web_settings_pools])
+        return cls(
+            pools=[Pool.from_vnish(p) for p in web_settings_pools if p["url"] != ""]
+        )
 
     @classmethod
     def from_boser(cls, grpc_pool_group: dict) -> "PoolGroup":
@@ -402,10 +398,18 @@ class PoolGroup(MinerConfigValue):
     def from_bitaxe(cls, web_system_info: dict) -> "PoolGroup":
         return cls(pools=[Pool.from_bitaxe(web_system_info)])
 
+    @classmethod
+    def from_iceriver(cls, web_userpanel: dict) -> "PoolGroup":
+        return cls(
+            pools=[
+                Pool.from_iceriver(web_pool)
+                for web_pool in web_userpanel["data"]["pools"]
+            ]
+        )
+
 
-@dataclass
 class PoolConfig(MinerConfigValue):
-    groups: List[PoolGroup] = field(default_factory=list)
+    groups: List[PoolGroup] = Field(default_factory=list)
 
     @classmethod
     def default(cls) -> "PoolConfig":
@@ -427,52 +431,52 @@ class PoolConfig(MinerConfigValue):
             group_pools.append(pool)
         return cls(groups=[PoolGroup(pools=group_pools)])
 
-    def as_am_modern(self, user_suffix: str = None) -> dict:
+    def as_am_modern(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {"pools": self.groups[0].as_am_modern(user_suffix=user_suffix)}
         return {"pools": PoolGroup().as_am_modern()}
 
-    def as_wm(self, user_suffix: str = None) -> dict:
+    def as_wm(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {"pools": self.groups[0].as_wm(user_suffix=user_suffix)}
         return {"pools": PoolGroup().as_wm()}
 
-    def as_am_old(self, user_suffix: str = None) -> dict:
+    def as_am_old(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return self.groups[0].as_am_old(user_suffix=user_suffix)
         return PoolGroup().as_am_old()
 
-    def as_goldshell(self, user_suffix: str = None) -> dict:
+    def as_goldshell(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {"pools": self.groups[0].as_goldshell(user_suffix=user_suffix)}
         return {"pools": PoolGroup().as_goldshell()}
 
-    def as_avalon(self, user_suffix: str = None) -> dict:
+    def as_avalon(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {"pools": self.groups[0].as_avalon(user_suffix=user_suffix)}
         return {"pools": PoolGroup().as_avalon()}
 
-    def as_inno(self, user_suffix: str = None) -> dict:
+    def as_inno(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return self.groups[0].as_inno(user_suffix=user_suffix)
         return PoolGroup().as_inno()
 
-    def as_bosminer(self, user_suffix: str = None) -> dict:
+    def as_bosminer(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {
                 "group": [g.as_bosminer(user_suffix=user_suffix) for g in self.groups]
             }
         return {"group": [PoolGroup().as_bosminer()]}
 
-    def as_boser(self, user_suffix: str = None) -> dict:
+    def as_boser(self, user_suffix: str | None = 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],
             )
         }
 
-    def as_auradine(self, user_suffix: str = None) -> dict:
+    def as_auradine(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {
                 "updatepools": {
@@ -481,7 +485,7 @@ class PoolConfig(MinerConfigValue):
             }
         return {"updatepools": {"pools": PoolGroup().as_auradine()}}
 
-    def as_epic(self, user_suffix: str = None) -> dict:
+    def as_epic(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {
                 "pools": {
@@ -498,14 +502,20 @@ class PoolConfig(MinerConfigValue):
             }
         }
 
-    def as_mara(self, user_suffix: str = None) -> dict:
+    def as_mara(self, user_suffix: str | None = None) -> dict:
         if len(self.groups) > 0:
             return {"pools": self.groups[0].as_mara(user_suffix=user_suffix)}
         return {"pools": []}
 
-    def as_bitaxe(self, user_suffix: str = None) -> dict:
+    def as_bitaxe(self, user_suffix: str | None = None) -> dict:
         return self.groups[0].as_bitaxe(user_suffix=user_suffix)
 
+    def as_luxos(self, user_suffix: str | None = None) -> dict:
+        return {}
+
+    def as_vnish(self, user_suffix: str | None = None) -> dict:
+        return self.groups[0].as_vnish(user_suffix=user_suffix)
+
     @classmethod
     def from_api(cls, api_pools: dict) -> "PoolConfig":
         try:
@@ -514,38 +524,38 @@ class PoolConfig(MinerConfigValue):
             return PoolConfig.default()
         pool_data = sorted(pool_data, key=lambda x: int(x["POOL"]))
 
-        return cls([PoolGroup.from_api(pool_data)])
+        return cls(groups=[PoolGroup.from_api(pool_data)])
 
     @classmethod
     def from_epic(cls, web_conf: dict) -> "PoolConfig":
         pool_data = web_conf["StratumConfigs"]
-        return cls([PoolGroup.from_epic(pool_data)])
+        return cls(groups=[PoolGroup.from_epic(pool_data)])
 
     @classmethod
     def from_am_modern(cls, web_conf: dict) -> "PoolConfig":
         pool_data = web_conf["pools"]
 
-        return cls([PoolGroup.from_am_modern(pool_data)])
+        return cls(groups=[PoolGroup.from_am_modern(pool_data)])
 
     @classmethod
     def from_goldshell(cls, web_pools: list) -> "PoolConfig":
-        return cls([PoolGroup.from_goldshell(web_pools)])
+        return cls(groups=[PoolGroup.from_goldshell(web_pools)])
 
     @classmethod
     def from_inno(cls, web_pools: list) -> "PoolConfig":
-        return cls([PoolGroup.from_inno(web_pools)])
+        return cls(groups=[PoolGroup.from_inno(web_pools)])
 
     @classmethod
     def from_bosminer(cls, toml_conf: dict) -> "PoolConfig":
         if toml_conf.get("group") is None:
             return cls()
 
-        return cls([PoolGroup.from_bosminer(g) for g in toml_conf["group"]])
+        return cls(groups=[PoolGroup.from_bosminer(g) for g in toml_conf["group"]])
 
     @classmethod
     def from_vnish(cls, web_settings: dict) -> "PoolConfig":
         try:
-            return cls([PoolGroup.from_vnish(web_settings["miner"]["pools"])])
+            return cls(groups=[PoolGroup.from_vnish(web_settings["miner"]["pools"])])
         except LookupError:
             return cls()
 
@@ -568,3 +578,24 @@ class PoolConfig(MinerConfigValue):
     @classmethod
     def from_bitaxe(cls, web_system_info: dict) -> "PoolConfig":
         return cls(groups=[PoolGroup.from_bitaxe(web_system_info)])
+
+    @classmethod
+    def from_iceriver(cls, web_userpanel: dict) -> "PoolConfig":
+        return cls(groups=[PoolGroup.from_iceriver(web_userpanel)])
+
+    @classmethod
+    def from_luxos(cls, rpc_groups: dict, rpc_pools: dict) -> "PoolConfig":
+        return cls(
+            groups=[
+                PoolGroup(
+                    pools=[
+                        Pool.from_luxos(pool)
+                        for pool in rpc_pools["POOLS"]
+                        if pool["GROUP"] == group["GROUP"]
+                    ],
+                    name=group["Name"],
+                    quota=group["Quota"],
+                )
+                for group in rpc_groups["GROUPS"]
+            ]
+        )

pyasic/config/temperature.py

@@ -20,11 +20,10 @@ from dataclasses import dataclass
 from pyasic.config.base import MinerConfigValue
 
 
-@dataclass
 class TemperatureConfig(MinerConfigValue):
-    target: int = None
-    hot: int = None
-    danger: int = None
+    target: int | None = None
+    hot: int | None = None
+    danger: int | None = None
 
     @classmethod
     def default(cls):
@@ -54,6 +53,12 @@ class TemperatureConfig(MinerConfigValue):
             temps_config["temps"]["shutdown"] = self.hot
         return temps_config
 
+    def as_luxos(self) -> dict:
+        return {"tempctrlset": [self.target or "", self.hot or "", self.danger or ""]}
+
+    def as_vnish(self) -> dict:
+        return {"misc": {"restart_temp": self.danger}}
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "TemperatureConfig":
         return cls(
@@ -93,9 +98,16 @@ class TemperatureConfig(MinerConfigValue):
 
     @classmethod
     def from_vnish(cls, web_settings: dict) -> "TemperatureConfig":
+        try:
+            dangerous_temp = web_settings["misc"]["restart_temp"]
+        except KeyError:
+            dangerous_temp = None
         try:
             if web_settings["miner"]["cooling"]["mode"]["name"] == "auto":
-                return cls(target=web_settings["miner"]["cooling"]["mode"]["param"])
+                return cls(
+                    target=web_settings["miner"]["cooling"]["mode"]["param"],
+                    danger=dangerous_temp,
+                )
         except KeyError:
             pass
         return cls()
@@ -130,3 +142,16 @@ class TemperatureConfig(MinerConfigValue):
 
             return cls(**conf)
         return cls.default()
+
+    @classmethod
+    def from_luxos(cls, rpc_tempctrl: dict) -> "TemperatureConfig":
+        try:
+            tempctrl_config = rpc_tempctrl["TEMPCTRL"][0]
+            return cls(
+                target=tempctrl_config.get("Target"),
+                hot=tempctrl_config.get("Hot"),
+                danger=tempctrl_config.get("Dangerous"),
+            )
+        except LookupError:
+            pass
+        return cls.default()

pyasic/data/__init__.py

@@ -13,27 +13,27 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-
 import copy
-import json
 import time
-from dataclasses import asdict, dataclass, field, fields
 from datetime import datetime, timezone
 from typing import Any, List, Union
 
+from pydantic import BaseModel, Field, computed_field
+
 from pyasic.config import MinerConfig
 from pyasic.config.mining import MiningModePowerTune
+from pyasic.data.pools import PoolMetrics, Scheme
+from pyasic.device.algorithm.hashrate import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.base import GenericHashrate
 
+from ..device.algorithm.hashrate.unit.base import GenericUnit
 from .boards import HashBoard
 from .device import DeviceInfo
 from .error_codes import BraiinsOSError, InnosiliconError, WhatsminerError, X19Error
 from .fans import Fan
-from .hashrate import AlgoHashRate, HashUnit
-from pyasic.data.pools import PoolMetrics
 
 
-@dataclass
-class MinerData:
+class MinerData(BaseModel):
     """A Dataclass to standardize data returned from miners (specifically `AnyMiner().get_data()`)
 
     Attributes:
@@ -50,8 +50,8 @@ class MinerData:
         fw_ver: The current firmware version on the miner as a str.
         hostname: The network hostname of the miner as a str.
         hashrate: The hashrate of the miner in TH/s as a float.  Calculated automatically.
-        _hashrate: Backup for hashrate found via API instead of hashboards.
         expected_hashrate: The factory nominal hashrate of the miner in TH/s as a float.
+        sticker_hashrate: The factory sticker hashrate of the miner as a float.
         hashboards: A list of [`HashBoard`][pyasic.data.HashBoard]s on the miner with their statistics.
         temperature_avg: The average temperature across the boards.  Calculated automatically.
         env_temp: The environment temps as a float.
@@ -77,58 +77,47 @@ class MinerData:
 
     # general
     ip: str
-    _datetime: datetime = field(repr=False, default=None)
-    datetime: str = field(init=False)
-    timestamp: int = field(init=False)
+    raw_datetime: datetime = Field(
+        exclude=True, default_factory=datetime.now(timezone.utc).astimezone, repr=False
+    )
 
     # about
-    device_info: DeviceInfo = None
-    make: str = field(init=False)
-    model: str = field(init=False)
-    firmware: str = field(init=False)
-    algo: str = field(init=False)
-    mac: str = None
-    api_ver: str = None
-    fw_ver: str = None
-    hostname: str = None
+    device_info: DeviceInfo | None = None
+    mac: str | None = None
+    api_ver: str | None = None
+    fw_ver: str | None = None
+    hostname: str | None = None
 
     # hashrate
-    hashrate: AlgoHashRate = field(init=False)
-    _hashrate: AlgoHashRate = field(repr=False, default=None)
+    raw_hashrate: AlgoHashRateType = Field(exclude=True, default=None, repr=False)
+
+    # sticker
+    sticker_hashrate: AlgoHashRateType | None = None
 
     # expected
-    expected_hashrate: float = None
-    expected_hashboards: int = None
-    expected_chips: int = None
-    expected_fans: int = None
-
-    # % expected
-    percent_expected_chips: float = field(init=False)
-    percent_expected_hashrate: float = field(init=False)
-    percent_expected_wattage: float = field(init=False)
+    expected_hashrate: AlgoHashRateType | None = None
+    expected_hashboards: int | None = None
+    expected_chips: int | None = None
+    expected_fans: int | None = None
 
     # temperature
-    temperature_avg: int = field(init=False)
-    env_temp: float = None
+    env_temp: float | None = None
 
     # power
-    wattage: int = None
-    wattage_limit: int = field(init=False)
-    voltage: float = None
-    _wattage_limit: int = field(repr=False, default=None)
+    wattage: int | None = None
+    voltage: float | None = None
+    raw_wattage_limit: int | None = Field(exclude=True, default=None, repr=False)
 
     # fans
-    fans: List[Fan] = field(default_factory=list)
-    fan_psu: int = None
+    fans: List[Fan] = Field(default_factory=list)
+    fan_psu: int | None = None
 
     # boards
-    hashboards: List[HashBoard] = field(default_factory=list)
-    total_chips: int = field(init=False)
-    nominal: bool = field(init=False)
+    hashboards: List[HashBoard] = Field(default_factory=list)
 
     # config
-    config: MinerConfig = None
-    fault_light: Union[bool, None] = None
+    config: MinerConfig | None = None
+    fault_light: bool | None = None
 
     # errors
     errors: List[
@@ -138,26 +127,18 @@ class MinerData:
             X19Error,
             InnosiliconError,
         ]
-    ] = field(default_factory=list)
+    ] = Field(default_factory=list)
 
     # mining state
     is_mining: bool = True
-    uptime: int = None
-    efficiency: int = field(init=False)
+    uptime: int | None = None
 
     # pools
-    pools: list[PoolMetrics] = field(default_factory=list)
+    pools: list[PoolMetrics] = Field(default_factory=list)
 
     @classmethod
     def fields(cls):
-        return [f.name for f in fields(cls) if not f.name.startswith("_")]
-
-    @staticmethod
-    def dict_factory(x):
-        return {k: v for (k, v) in x if not k.startswith("_")}
-
-    def __post_init__(self):
-        self._datetime = datetime.now(timezone.utc).astimezone()
+        return list(cls.model_fields.keys())
 
     def get(self, __key: str, default: Any = None):
         try:
@@ -185,19 +166,19 @@ class MinerData:
 
     def __floordiv__(self, other):
         cp = copy.deepcopy(self)
-        for key in self:
+        for key in self.fields():
             item = getattr(self, key)
             if isinstance(item, int):
                 setattr(cp, key, item // other)
             if isinstance(item, float):
-                setattr(cp, key, round(item / other, 2))
+                setattr(cp, key, item / other)
         return cp
 
     def __add__(self, other):
         if not isinstance(other, MinerData):
             raise TypeError("Cannot add MinerData to non MinerData type.")
         cp = copy.deepcopy(self)
-        for key in self:
+        for key in self.fields():
             item = getattr(self, key)
             other_item = getattr(other, key)
             if item is None:
@@ -217,34 +198,37 @@ class MinerData:
                 setattr(cp, key, item & other_item)
         return cp
 
+    @computed_field  # type: ignore[misc]
     @property
-    def hashrate(self):  # noqa - Skip PyCharm inspection
+    def hashrate(self) -> AlgoHashRateType | None:
         if len(self.hashboards) > 0:
             hr_data = []
             for item in self.hashboards:
                 if item.hashrate is not None:
                     hr_data.append(item.hashrate)
             if len(hr_data) > 0:
-                return sum(hr_data, start=type(hr_data[0])(0))
-        return self._hashrate
+                return sum(hr_data, start=self.device_info.algo.hashrate(rate=0))
+        return self.raw_hashrate
 
     @hashrate.setter
     def hashrate(self, val):
-        self._hashrate = val
+        self.raw_hashrate = val
 
+    @computed_field  # type: ignore[misc]
     @property
-    def wattage_limit(self):  # noqa - Skip PyCharm inspection
+    def wattage_limit(self) -> int | None:
         if self.config is not None:
             if isinstance(self.config.mining_mode, MiningModePowerTune):
                 return self.config.mining_mode.power
-        return self._wattage_limit
+        return self.raw_wattage_limit
 
     @wattage_limit.setter
     def wattage_limit(self, val: int):
-        self._wattage_limit = val
+        self.raw_wattage_limit = val
 
+    @computed_field  # type: ignore[misc]
     @property
-    def total_chips(self):  # noqa - Skip PyCharm inspection
+    def total_chips(self) -> int | None:
         if len(self.hashboards) > 0:
             chip_data = []
             for item in self.hashboards:
@@ -254,34 +238,25 @@ class MinerData:
                 return sum(chip_data)
             return None
 
-    @total_chips.setter
-    def total_chips(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def nominal(self):  # noqa - Skip PyCharm inspection
+    def nominal(self) -> bool | None:
         if self.total_chips is None or self.expected_chips is None:
             return None
         return self.expected_chips == self.total_chips
 
-    @nominal.setter
-    def nominal(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def percent_expected_chips(self):  # noqa - Skip PyCharm inspection
+    def percent_expected_chips(self) -> int | None:
         if self.total_chips is None or self.expected_chips is None:
             return None
         if self.total_chips == 0 or self.expected_chips == 0:
             return 0
         return round((self.total_chips / self.expected_chips) * 100)
 
-    @percent_expected_chips.setter
-    def percent_expected_chips(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def percent_expected_hashrate(self):  # noqa - Skip PyCharm inspection
+    def percent_expected_hashrate(self) -> int | None:
         if self.hashrate is None or self.expected_hashrate is None:
             return None
         try:
@@ -289,12 +264,9 @@ class MinerData:
         except ZeroDivisionError:
             return 0
 
-    @percent_expected_hashrate.setter
-    def percent_expected_hashrate(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def percent_expected_wattage(self):  # noqa - Skip PyCharm inspection
+    def percent_expected_wattage(self) -> int | None:
         if self.wattage_limit is None or self.wattage is None:
             return None
         try:
@@ -302,12 +274,9 @@ class MinerData:
         except ZeroDivisionError:
             return 0
 
-    @percent_expected_wattage.setter
-    def percent_expected_wattage(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def temperature_avg(self):  # noqa - Skip PyCharm inspection
+    def temperature_avg(self) -> int | None:
         total_temp = 0
         temp_count = 0
         for hb in self.hashboards:
@@ -318,12 +287,9 @@ class MinerData:
             return None
         return round(total_temp / temp_count)
 
-    @temperature_avg.setter
-    def temperature_avg(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def efficiency(self):  # noqa - Skip PyCharm inspection
+    def efficiency(self) -> int | None:
         if self.hashrate is None or self.wattage is None:
             return None
         try:
@@ -331,67 +297,45 @@ class MinerData:
         except ZeroDivisionError:
             return 0
 
-    @efficiency.setter
-    def efficiency(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def datetime(self):  # noqa - Skip PyCharm inspection
-        return self._datetime.isoformat()
-
-    @datetime.setter
-    def datetime(self, val):
-        pass
+    def datetime(self) -> str:
+        return self.raw_datetime.isoformat()
 
+    @computed_field  # type: ignore[misc]
     @property
-    def timestamp(self):  # noqa - Skip PyCharm inspection
-        return int(time.mktime(self._datetime.timetuple()))
-
-    @timestamp.setter
-    def timestamp(self, val):
-        pass
+    def timestamp(self) -> int:
+        return int(time.mktime(self.raw_datetime.timetuple()))
 
+    @computed_field  # type: ignore[misc]
     @property
-    def make(self):  # noqa - Skip PyCharm inspection
+    def make(self) -> str:
         if self.device_info.make is not None:
             return str(self.device_info.make)
 
-    @make.setter
-    def make(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def model(self):  # noqa - Skip PyCharm inspection
+    def model(self) -> str:
         if self.device_info.model is not None:
             return str(self.device_info.model)
 
-    @model.setter
-    def model(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def firmware(self):  # noqa - Skip PyCharm inspection
+    def firmware(self) -> str:
         if self.device_info.firmware is not None:
             return str(self.device_info.firmware)
 
-    @firmware.setter
-    def firmware(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
-    def algo(self):  # noqa - Skip PyCharm inspection
+    def algo(self) -> str:
         if self.device_info.algo is not None:
             return str(self.device_info.algo)
 
-    @algo.setter
-    def algo(self, val):
-        pass
-
     def keys(self) -> list:
-        return [f.name for f in fields(self)]
+        return list(self.model_fields.keys())
 
     def asdict(self) -> dict:
-        return asdict(self, dict_factory=self.dict_factory)
+        return self.model_dump()
 
     def as_dict(self) -> dict:
         """Get this dataclass as a dictionary.
@@ -407,7 +351,7 @@ class MinerData:
         Returns:
             A JSON version of this class.
         """
-        return json.dumps(self.as_dict())
+        return self.model_dump_json()
 
     def as_csv(self) -> str:
         """Get this dataclass as CSV.
@@ -436,7 +380,7 @@ class MinerData:
         field_data = []
 
         tags = ["ip", "mac", "model", "hostname"]
-        for attribute in self:
+        for attribute in self.fields():
             if attribute in tags:
                 escaped_data = self.get(attribute, "Unknown").replace(" ", "\\ ")
                 tag_data.append(f"{attribute}={escaped_data}")

pyasic/data/boards.py

@@ -13,15 +13,16 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import Any
 
-from .hashrate import AlgoHashRate
+from pydantic import BaseModel, field_serializer
+
+from pyasic.device.algorithm.hashrate import AlgoHashRateType
 
 
-@dataclass
-class HashBoard:
+class HashBoard(BaseModel):
     """A Dataclass to standardize hashboard data.
 
     Attributes:
@@ -39,16 +40,16 @@ class HashBoard:
     """
 
     slot: int = 0
-    hashrate: AlgoHashRate = None
-    temp: int = None
-    chip_temp: int = None
-    chips: int = None
-    expected_chips: int = None
-    serial_number: str = None
+    hashrate: AlgoHashRateType | None = None
+    temp: float | None = None
+    chip_temp: float | None = None
+    chips: int | None = None
+    expected_chips: int | None = None
+    serial_number: str | None = None
     missing: bool = True
-    tuned: bool = None
-    active: bool = None
-    voltage: float = None
+    tuned: bool | None = None
+    active: bool | None = None
+    voltage: float | None = None
 
     def get(self, __key: str, default: Any = None):
         try:

pyasic/data/device.py

@@ -1,14 +1,31 @@
-from dataclasses import dataclass
+from pydantic import BaseModel, ConfigDict, field_serializer
 
-from pyasic.device.algorithm import MinerAlgo
+from pyasic.device.algorithm import MinerAlgoType
 from pyasic.device.firmware import MinerFirmware
 from pyasic.device.makes import MinerMake
-from pyasic.device.models import MinerModel
+from pyasic.device.models import MinerModelType
 
 
-@dataclass
-class DeviceInfo:
-    make: MinerMake = None
-    model: MinerModel = None
-    firmware: MinerFirmware = None
-    algo: MinerAlgo = None
+class DeviceInfo(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    make: MinerMake | None = None
+    model: MinerModelType | None = None
+    firmware: MinerFirmware | None = None
+    algo: type[MinerAlgoType] | None = None
+
+    @field_serializer("make")
+    def serialize_make(self, make: MinerMake, _info):
+        return str(make)
+
+    @field_serializer("model")
+    def serialize_model(self, model: MinerModelType, _info):
+        return str(model)
+
+    @field_serializer("firmware")
+    def serialize_firmware(self, firmware: MinerFirmware, _info):
+        return str(firmware)
+
+    @field_serializer("algo")
+    def serialize_algo(self, algo: MinerAlgoType, _info):
+        return str(algo)

pyasic/data/error_codes/X19.py

@@ -13,12 +13,10 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-
-from dataclasses import asdict, dataclass, fields
+from pyasic.data.error_codes.base import BaseMinerError
 
 
-@dataclass
-class X19Error:
+class X19Error(BaseMinerError):
     """A Dataclass to handle error codes of X19 miners.
 
     Attributes:
@@ -28,10 +26,3 @@ class X19Error:
 
     error_message: str
     error_code: int = 0
-
-    @classmethod
-    def fields(cls):
-        return fields(cls)
-
-    def asdict(self):
-        return asdict(self)

pyasic/data/error_codes/base.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+
+
+class BaseMinerError(BaseModel):
+    @classmethod
+    def fields(cls):
+        return list(cls.model_fields.keys())
+
+    def asdict(self) -> dict:
+        return self.model_dump()
+
+    def as_dict(self) -> dict:
+        """Get this dataclass as a dictionary.
+
+        Returns:
+            A dictionary version of this class.
+        """
+        return self.asdict()

pyasic/data/error_codes/bos.py

@@ -14,11 +14,10 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from dataclasses import asdict, dataclass, fields
+from pyasic.data.error_codes.base import BaseMinerError
 
 
-@dataclass
-class BraiinsOSError:
+class BraiinsOSError(BaseMinerError):
     """A Dataclass to handle error codes of BraiinsOS+ miners.
 
     Attributes:
@@ -28,10 +27,3 @@ class BraiinsOSError:
 
     error_message: str
     error_code: int = 0
-
-    @classmethod
-    def fields(cls):
-        return fields(cls)
-
-    def asdict(self):
-        return asdict(self)

pyasic/data/error_codes/innosilicon.py

@@ -14,11 +14,13 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from dataclasses import asdict, dataclass, field, fields
+
+from pydantic import computed_field
+
+from pyasic.data.error_codes.base import BaseMinerError
 
 
-@dataclass
-class InnosiliconError:
+class InnosiliconError(BaseMinerError):
     """A Dataclass to handle error codes of Innosilicon miners.
 
     Attributes:
@@ -27,25 +29,14 @@ class InnosiliconError:
     """
 
     error_code: int
-    error_message: str = field(init=False)
-
-    @classmethod
-    def fields(cls):
-        return fields(cls)
 
+    @computed_field  # type: ignore[misc]
     @property
-    def error_message(self):  # noqa - Skip PyCharm inspection
+    def error_message(self) -> str:  # noqa - Skip PyCharm inspection
         if self.error_code in ERROR_CODES:
             return ERROR_CODES[self.error_code]
         return "Unknown error type."
 
-    @error_message.setter
-    def error_message(self, val):
-        pass
-
-    def asdict(self):
-        return asdict(self)
-
 
 ERROR_CODES = {
     21: "The PLUG signal of the hash board is not detected.",

pyasic/data/error_codes/whatsminer.py

@@ -13,12 +13,12 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+from pydantic import computed_field
 
-from dataclasses import asdict, dataclass, field, fields
+from pyasic.data.error_codes.base import BaseMinerError
 
 
-@dataclass
-class WhatsminerError:
+class WhatsminerError(BaseMinerError):
     """A Dataclass to handle error codes of Whatsminers.
 
     Attributes:
@@ -27,14 +27,10 @@ class WhatsminerError:
     """
 
     error_code: int
-    error_message: str = field(init=False)
-
-    @classmethod
-    def fields(cls):
-        return fields(cls)
 
+    @computed_field  # type: ignore[misc]
     @property
-    def error_message(self):  # noqa - Skip PyCharm inspection
+    def error_message(self) -> str:  # noqa - Skip PyCharm inspection
         if len(str(self.error_code)) == 6 and not str(self.error_code)[:1] == "1":
             err_type = int(str(self.error_code)[:2])
             err_subtype = int(str(self.error_code)[2:3])
@@ -74,13 +70,6 @@ class WhatsminerError:
         except KeyError:
             return "Unknown error type."
 
-    @error_message.setter
-    def error_message(self, val):
-        pass
-
-    def asdict(self):
-        return asdict(self)
-
 
 ERROR_CODES = {
     1: {  # Fan error

pyasic/data/fans.py

@@ -14,12 +14,12 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from dataclasses import dataclass
 from typing import Any
 
+from pydantic import BaseModel
 
-@dataclass
-class Fan:
+
+class Fan(BaseModel):
     """A Dataclass to standardize fan data.
 
     Attributes:

pyasic/data/hashrate/__init__.py

@@ -1,15 +0,0 @@
-from enum import Enum
-
-from pyasic.data.hashrate.sha256 import SHA256HashRate
-from pyasic.device.algorithm.sha256 import SHA256Unit
-
-
-class AlgoHashRate(Enum):
-    SHA256 = SHA256HashRate
-
-    def __call__(self, *args, **kwargs):
-        return self.value(*args, **kwargs)
-
-
-class HashUnit:
-    SHA256 = SHA256Unit

pyasic/data/hashrate/sha256.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from pyasic.device.algorithm import MinerAlgo
-from pyasic.device.algorithm.sha256 import SHA256Unit
-
-
-@dataclass
-class SHA256HashRate:
-    rate: float
-    unit: SHA256Unit = MinerAlgo.SHA256.unit.default
-
-    def __float__(self):
-        return float(self.rate)
-
-    def __int__(self):
-        return int(self.rate)
-
-    def __repr__(self):
-        return f"{self.rate} {str(self.unit)}"
-
-    def __round__(self, n: int = None):
-        return round(self.rate, n)
-
-    def __add__(self, other: SHA256HashRate | int | float) -> SHA256HashRate:
-        if isinstance(other, SHA256HashRate):
-            return SHA256HashRate(self.rate + other.into(self.unit).rate, self.unit)
-        return SHA256HashRate(self.rate + other, self.unit)
-
-    def __sub__(self, other: SHA256HashRate | int | float) -> SHA256HashRate:
-        if isinstance(other, SHA256HashRate):
-            return SHA256HashRate(self.rate - other.into(self.unit).rate, self.unit)
-        return SHA256HashRate(self.rate - other, self.unit)
-
-    def __truediv__(self, other: SHA256HashRate | int | float):
-        if isinstance(other, SHA256HashRate):
-            return SHA256HashRate(self.rate / other.into(self.unit).rate, self.unit)
-        return SHA256HashRate(self.rate / other, self.unit)
-
-    def __floordiv__(self, other: SHA256HashRate | int | float):
-        if isinstance(other, SHA256HashRate):
-            return SHA256HashRate(self.rate // other.into(self.unit).rate, self.unit)
-        return SHA256HashRate(self.rate // other, self.unit)
-
-    def __mul__(self, other: SHA256HashRate | int | float):
-        if isinstance(other, SHA256HashRate):
-            return SHA256HashRate(self.rate * other.into(self.unit).rate, self.unit)
-        return SHA256HashRate(self.rate * other, self.unit)
-
-    def into(self, other: SHA256Unit) -> SHA256HashRate:
-        return SHA256HashRate(
-            rate=self.rate / (other.value / self.unit.value), unit=other
-        )

pyasic/data/pools.py

@@ -1,21 +1,27 @@
-from dataclasses import dataclass, field
 from enum import Enum
 from typing import Optional
 from urllib.parse import urlparse
 
+from pydantic import BaseModel, computed_field, model_serializer
+from typing_extensions import Self
+
 
 class Scheme(Enum):
     STRATUM_V1 = "stratum+tcp"
     STRATUM_V2 = "stratum2+tcp"
+    STRATUM_V1_SSL = "stratum+ssl"
 
 
-@dataclass
-class PoolUrl:
+class PoolUrl(BaseModel):
     scheme: Scheme
     host: str
     port: int
     pubkey: Optional[str] = None
 
+    @model_serializer
+    def serialize(self):
+        return str(self)
+
     def __str__(self) -> str:
         if self.scheme == Scheme.STRATUM_V2 and self.pubkey:
             return f"{self.scheme.value}://{self.host}:{self.port}/{self.pubkey}"
@@ -23,17 +29,21 @@ class PoolUrl:
             return f"{self.scheme.value}://{self.host}:{self.port}"
 
     @classmethod
-    def from_str(cls, url: str) -> "PoolUrl":
+    def from_str(cls, url: str) -> Self | None:
         parsed_url = urlparse(url)
-        scheme = Scheme(parsed_url.scheme)
+        if not parsed_url.hostname:
+            return None
+        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
         return cls(scheme=scheme, host=host, port=port, pubkey=pubkey)
 
 
-@dataclass
-class PoolMetrics:
+class PoolMetrics(BaseModel):
     """A dataclass to standardize pool metrics returned from miners.
     Attributes:
 
@@ -50,27 +60,23 @@ class PoolMetrics:
     pool_stale_percent: Percentage of stale shares by the pool.
     """
 
-    url: PoolUrl
-    accepted: int = None
-    rejected: int = None
-    get_failures: int = None
-    remote_failures: int = None
-    active: bool = None
-    alive: bool = None
-    index: int = None
-    user: str = None
-    pool_rejected_percent: float = field(init=False)
-    pool_stale_percent: float = field(init=False)
+    url: PoolUrl | None
+    accepted: int | None = None
+    rejected: int | None = None
+    get_failures: int | None = None
+    remote_failures: int | None = None
+    active: bool | None = None
+    alive: bool | None = None
+    index: int | None = None
+    user: str | None = None
 
+    @computed_field  # type: ignore[misc]
     @property
     def pool_rejected_percent(self) -> float:  # noqa - Skip PyCharm inspection
         """Calculate and return the percentage of rejected shares"""
         return self._calculate_percentage(self.rejected, self.accepted + self.rejected)
 
-    @pool_rejected_percent.setter
-    def pool_rejected_percent(self, val):
-        pass
-
+    @computed_field  # type: ignore[misc]
     @property
     def pool_stale_percent(self) -> float:  # noqa - Skip PyCharm inspection
         """Calculate and return the percentage of stale shares."""
@@ -78,13 +84,11 @@ class PoolMetrics:
             self.get_failures, self.accepted + self.rejected
         )
 
-    @pool_stale_percent.setter
-    def pool_stale_percent(self, val):
-        pass
-
     @staticmethod
     def _calculate_percentage(value: int, total: int) -> float:
         """Calculate the percentage."""
+        if value is None or total is None:
+            return 0
         if total == 0:
             return 0
         return (value / total) * 100

pyasic/device/algorithm/__init__.py

@@ -1,5 +1,26 @@
-from pyasic.device.algorithm.sha256 import SHA256Algo
+from .base import MinerAlgoType
+from .blake256 import Blake256Algo
+from .eaglesong import EaglesongAlgo
+from .equihash import EquihashAlgo
+from .ethash import EtHashAlgo
+from .handshake import HandshakeAlgo
+from .hashrate import *
+from .hashrate.unit import *
+from .kadena import KadenaAlgo
+from .kheavyhash import KHeavyHashAlgo
+from .scrypt import ScryptAlgo
+from .sha256 import SHA256Algo
+from .x11 import X11Algo
 
 
 class MinerAlgo:
     SHA256 = SHA256Algo
+    SCRYPT = ScryptAlgo
+    KHEAVYHASH = KHeavyHashAlgo
+    KADENA = KadenaAlgo
+    HANDSHAKE = HandshakeAlgo
+    X11 = X11Algo
+    BLAKE256 = Blake256Algo
+    EAGLESONG = EaglesongAlgo
+    ETHASH = EtHashAlgo
+    EQUIHASH = EquihashAlgo

pyasic/device/algorithm/base.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from .hashrate.base import AlgoHashRateType, GenericHashrate
+from .hashrate.unit.base import AlgoHashRateUnitType, GenericUnit
+
+
+class MinerAlgoMeta(type):
+    name: str
+
+    def __str__(cls):
+        return cls.name
+
+
+class MinerAlgoType(metaclass=MinerAlgoMeta):
+    hashrate: type[AlgoHashRateType]
+    unit: type[AlgoHashRateUnitType]
+
+
+class GenericAlgo(MinerAlgoType):
+    hashrate: type[GenericHashrate] = GenericHashrate
+    unit: type[GenericUnit] = GenericUnit
+
+    name = "Generic (Unknown)"

pyasic/device/algorithm/blake256.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import Blake256HashRate
+from .hashrate.unit import Blake256Unit
+
+
+# make this json serializable
+class Blake256Algo(MinerAlgoType):
+    hashrate: type[Blake256HashRate] = Blake256HashRate
+    unit: type[Blake256Unit] = Blake256Unit
+
+    name = "Blake256"

pyasic/device/algorithm/eaglesong.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import EaglesongHashRate
+from .hashrate.unit import EaglesongUnit
+
+
+# make this json serializable
+class EaglesongAlgo(MinerAlgoType):
+    hashrate: type[EaglesongHashRate] = EaglesongHashRate
+    unit: type[EaglesongUnit] = EaglesongUnit
+
+    name = "Eaglesong"

pyasic/device/algorithm/equihash.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import EquihashHashRate
+from .hashrate.unit import EquihashUnit
+
+
+# make this json serializable
+class EquihashAlgo(MinerAlgoType):
+    hashrate: type[EquihashHashRate] = EquihashHashRate
+    unit: type[EquihashUnit] = EquihashUnit
+
+    name = "Equihash"

pyasic/device/algorithm/ethash.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import EtHashHashRate
+from .hashrate.unit import EtHashUnit
+
+
+class EtHashAlgo(MinerAlgoType):
+    hashrate: type[EtHashHashRate] = EtHashHashRate
+    unit: type[EtHashUnit] = EtHashUnit
+
+    name = "EtHash"

pyasic/device/algorithm/handshake.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import HandshakeHashRate
+from .hashrate.unit import HandshakeUnit
+
+
+# make this json serializable
+class HandshakeAlgo(MinerAlgoType):
+    hashrate: type[HandshakeHashRate] = HandshakeHashRate
+    unit: type[HandshakeUnit] = HandshakeUnit
+
+    name = "Handshake"

pyasic/device/algorithm/hashrate/__init__.py

@@ -0,0 +1,24 @@
+from .base import AlgoHashRateType
+from .blake256 import Blake256HashRate
+from .eaglesong import EaglesongHashRate
+from .equihash import EquihashHashRate
+from .ethash import EtHashHashRate
+from .handshake import HandshakeHashRate
+from .kadena import KadenaHashRate
+from .kheavyhash import KHeavyHashHashRate
+from .scrypt import ScryptHashRate
+from .sha256 import SHA256HashRate
+from .x11 import X11HashRate
+
+
+class AlgoHashRate:
+    SHA256 = SHA256HashRate
+    SCRYPT = ScryptHashRate
+    KHEAVYHASH = KHeavyHashHashRate
+    KADENA = KadenaHashRate
+    HANDSHAKE = HandshakeHashRate
+    X11 = X11HashRate
+    BLAKE256 = Blake256HashRate
+    EAGLESONG = EaglesongHashRate
+    ETHASH = EtHashHashRate
+    EQUIHASH = EquihashHashRate

pyasic/device/algorithm/hashrate/base.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from pydantic import BaseModel, field_serializer
+from typing_extensions import Self
+
+from .unit.base import AlgoHashRateUnitType, GenericUnit
+
+
+class AlgoHashRateType(BaseModel, ABC):
+    unit: AlgoHashRateUnitType
+    rate: float
+
+    @field_serializer("unit")
+    def serialize_unit(self, unit: AlgoHashRateUnitType):
+        return unit.model_dump()
+
+    @abstractmethod
+    def into(self, other: "AlgoHashRateUnitType"):
+        pass
+
+    def auto_unit(self):
+        if 1 < self.rate // int(self.unit.H) < 1000:
+            return self.into(self.unit.H)
+        if 1 < self.rate // int(self.unit.MH) < 1000:
+            return self.into(self.unit.MH)
+        if 1 < self.rate // int(self.unit.GH) < 1000:
+            return self.into(self.unit.GH)
+        if 1 < self.rate // int(self.unit.TH) < 1000:
+            return self.into(self.unit.TH)
+        if 1 < self.rate // int(self.unit.PH) < 1000:
+            return self.into(self.unit.PH)
+        if 1 < self.rate // int(self.unit.EH) < 1000:
+            return self.into(self.unit.EH)
+        if 1 < self.rate // int(self.unit.ZH) < 1000:
+            return self.into(self.unit.ZH)
+        return self
+
+    def __float__(self):
+        return float(self.rate)
+
+    def __int__(self):
+        return int(self.rate)
+
+    def __repr__(self):
+        return f"{self.rate} {str(self.unit)}"
+
+    def __round__(self, n: int = None):
+        return round(self.rate, n)
+
+    def __add__(self, other: Self | int | float) -> Self:
+        if isinstance(other, AlgoHashRateType):
+            return self.__class__(
+                rate=self.rate + other.into(self.unit).rate, unit=self.unit
+            )
+        return self.__class__(rate=self.rate + other, unit=self.unit)
+
+    def __sub__(self, other: Self | int | float) -> Self:
+        if isinstance(other, AlgoHashRateType):
+            return self.__class__(
+                rate=self.rate - other.into(self.unit).rate, unit=self.unit
+            )
+        return self.__class__(rate=self.rate - other, unit=self.unit)
+
+    def __truediv__(self, other: Self | int | float) -> Self:
+        if isinstance(other, AlgoHashRateType):
+            return self.__class__(
+                rate=self.rate / other.into(self.unit).rate, unit=self.unit
+            )
+        return self.__class__(rate=self.rate / other, unit=self.unit)
+
+    def __floordiv__(self, other: Self | int | float) -> Self:
+        if isinstance(other, AlgoHashRateType):
+            return self.__class__(
+                rate=self.rate // other.into(self.unit).rate, unit=self.unit
+            )
+        return self.__class__(rate=self.rate // other, unit=self.unit)
+
+    def __mul__(self, other: Self | int | float) -> Self:
+        if isinstance(other, AlgoHashRateType):
+            return self.__class__(
+                rate=self.rate * other.into(self.unit).rate, unit=self.unit
+            )
+        return self.__class__(rate=self.rate * other, unit=self.unit)
+
+
+class GenericHashrate(AlgoHashRateType):
+    rate: float = 0
+    unit: GenericUnit = GenericUnit.H
+
+    def into(self, other: GenericUnit):
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/blake256.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.blake256 import Blake256Unit
+
+from .unit import HashUnit
+
+
+class Blake256HashRate(AlgoHashRateType):
+    rate: float
+    unit: Blake256Unit = HashUnit.BLAKE256.default
+
+    def into(self, other: Blake256Unit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/eaglesong.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.eaglesong import EaglesongUnit
+
+from .unit import HashUnit
+
+
+class EaglesongHashRate(AlgoHashRateType):
+    rate: float
+    unit: EaglesongUnit = HashUnit.EAGLESONG.default
+
+    def into(self, other: EaglesongUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/equihash.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.equihash import EquihashUnit
+
+from .unit import HashUnit
+
+
+class EquihashHashRate(AlgoHashRateType):
+    rate: float
+    unit: EquihashUnit = HashUnit.ETHASH.default
+
+    def into(self, other: EquihashUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/ethash.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.ethash import EtHashUnit
+
+from .unit import HashUnit
+
+
+class EtHashHashRate(AlgoHashRateType):
+    rate: float
+    unit: EtHashUnit = HashUnit.ETHASH.default
+
+    def into(self, other: EtHashUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/handshake.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.handshake import HandshakeUnit
+
+from .unit import HashUnit
+
+
+class HandshakeHashRate(AlgoHashRateType):
+    rate: float
+    unit: HandshakeUnit = HashUnit.HANDSHAKE.default
+
+    def into(self, other: HandshakeUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/kadena.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.kadena import KadenaUnit
+
+from .unit import HashUnit
+
+
+class KadenaHashRate(AlgoHashRateType):
+    rate: float
+    unit: KadenaUnit = HashUnit.KADENA.default
+
+    def into(self, other: KadenaUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/kheavyhash.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.kheavyhash import KHeavyHashUnit
+
+from .unit import HashUnit
+
+
+class KHeavyHashHashRate(AlgoHashRateType):
+    rate: float
+    unit: KHeavyHashUnit = HashUnit.KHEAVYHASH.default
+
+    def into(self, other: KHeavyHashUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/scrypt.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.scrypt import ScryptUnit
+
+from .unit import HashUnit
+
+
+class ScryptHashRate(AlgoHashRateType):
+    rate: float
+    unit: ScryptUnit = HashUnit.SCRYPT.default
+
+    def into(self, other: ScryptUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/hashrate/sha256.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.sha256 import SHA256Unit
+
+from .unit import HashUnit
+
+
+class SHA256HashRate(AlgoHashRateType):
+    rate: float
+    unit: SHA256Unit = HashUnit.SHA256.default
+
+    def into(self, other: SHA256Unit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

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

@@ -0,0 +1,23 @@
+from .blake256 import Blake256Unit
+from .eaglesong import EaglesongUnit
+from .equihash import EquihashUnit
+from .ethash import EtHashUnit
+from .handshake import HandshakeUnit
+from .kadena import KadenaUnit
+from .kheavyhash import KHeavyHashUnit
+from .scrypt import ScryptUnit
+from .sha256 import SHA256Unit
+from .x11 import X11Unit
+
+
+class HashUnit:
+    SHA256 = SHA256Unit
+    SCRYPT = ScryptUnit
+    KHEAVYHASH = KHeavyHashUnit
+    KADENA = KadenaUnit
+    HANDSHAKE = HandshakeUnit
+    X11 = X11Unit
+    BLAKE256 = Blake256Unit
+    EAGLESONG = EaglesongUnit
+    ETHASH = EtHashUnit
+    EQUIHASH = EquihashUnit

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

@@ -0,0 +1,71 @@
+from enum import IntEnum
+
+
+class AlgoHashRateUnitType(IntEnum):
+    H: int
+    KH: int
+    MH: int
+    GH: int
+    TH: int
+    PH: int
+    EH: int
+    ZH: int
+
+    default: int
+
+    def __str__(self):
+        if self.value == self.H:
+            return "H/s"
+        if self.value == self.KH:
+            return "KH/s"
+        if self.value == self.MH:
+            return "MH/s"
+        if self.value == self.GH:
+            return "GH/s"
+        if self.value == self.TH:
+            return "TH/s"
+        if self.value == self.PH:
+            return "PH/s"
+        if self.value == self.EH:
+            return "EH/s"
+        if self.value == self.ZH:
+            return "ZH/s"
+
+    @classmethod
+    def from_str(cls, value: str):
+        if value == "H":
+            return cls.H
+        elif value == "KH":
+            return cls.KH
+        elif value == "MH":
+            return cls.MH
+        elif value == "GH":
+            return cls.GH
+        elif value == "TH":
+            return cls.TH
+        elif value == "PH":
+            return cls.PH
+        elif value == "EH":
+            return cls.EH
+        elif value == "ZH":
+            return cls.ZH
+        return cls.default
+
+    def __repr__(self):
+        return str(self)
+
+    def model_dump(self):
+        return {"value": self.value, "suffix": str(self)}
+
+
+class GenericUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = H

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class Blake256Unit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = TH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class EaglesongUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = TH

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

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class EquihashUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = KH
+
+    def __str__(self):
+        if self.value == self.H:
+            return "Sol/s"
+        if self.value == self.KH:
+            return "KSol/s"
+        if self.value == self.MH:
+            return "MSol/s"
+        if self.value == self.GH:
+            return "GSol/s"
+        if self.value == self.TH:
+            return "TSol/s"
+        if self.value == self.PH:
+            return "PSol/s"
+        if self.value == self.EH:
+            return "ESol/s"
+        if self.value == self.ZH:
+            return "ZSol/s"

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class EtHashUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = MH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class HandshakeUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = TH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class KadenaUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = TH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class KHeavyHashUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = TH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class ScryptUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = GH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class SHA256Unit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = TH

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

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class X11Unit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = GH

pyasic/device/algorithm/hashrate/x11.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.x11 import X11Unit
+
+from .unit import HashUnit
+
+
+class X11HashRate(AlgoHashRateType):
+    rate: float
+    unit: X11Unit = HashUnit.X11.default
+
+    def into(self, other: X11Unit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )

pyasic/device/algorithm/kadena.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import KadenaHashRate
+from .hashrate.unit import KadenaUnit
+
+
+# make this json serializable
+class KadenaAlgo(MinerAlgoType):
+    hashrate: type[KadenaHashRate] = KadenaHashRate
+    unit: type[KadenaUnit] = KadenaUnit
+
+    name = "Kadena"

pyasic/device/algorithm/kheavyhash.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import KHeavyHashHashRate
+from .hashrate.unit import KHeavyHashUnit
+
+
+# make this json serializable
+class KHeavyHashAlgo(MinerAlgoType):
+    hashrate: type[KHeavyHashHashRate] = KHeavyHashHashRate
+    unit: type[KHeavyHashUnit] = KHeavyHashUnit
+
+    name = "KHeavyHash"