version: bump version number

* feature: handle all hashrate algorithm conversions for antminers

* feature: handle all hashrate algorithm conversions for auradine

* feature: handle all hashrate algorithm conversions for avalonminers

* feature: handle all hashrate algorithm conversions for bitaxe

* feature: handle all hashrate algorithm conversions for epic

* feature: handle all hashrate algorithm conversions for goldshell

* refactor: clean up imports

* feature: handle all hashrate algorithm conversions for hammer

* feature: handle all hashrate algorithm conversions for iceriver

* feature: handle all hashrate algorithm conversions for innosilicon

* feature: handle all hashrate algorithm conversions for whatsminer

* tests: update tests to check if miners have board, fan, and algo values

* feature: finish updating all miners with boards, fans, and algos

* feature: update algorithm default values

* feature: add algorithm hashrate values

* feature: improve hashrate types, and use `self.algo` inside miners

---------

Co-authored-by: Upstream Data <brett@upstreamdata.ca>

.coveragerc

@@ -0,0 +1,17 @@
+[report]
+exclude_lines =
+    # Skip @abstractmethod
+    @abstractmethod
+    @abc.abstractmethod
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:

.dockerignore

@@ -1,8 +0,0 @@
-# Ignore VENV
-venv
-
-# Ignore builds
-build
-
-# Ignore github files
-.github

.github/workflows/python-publish.yml

@@ -0,0 +1,22 @@
+name: PyPI
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+    paths-ignore:
+      - '**.md'
+      - 'docs/**'
+      - 'docsrc/**'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Publish GH release
+        uses: softprops/action-gh-release@v0.1.14
+      - name: Build using poetry and publish to PyPi
+        uses: JRubics/poetry-publish@v1.11
+        with:
+          pypi_token: ${{ secrets.PYPI_API_KEY }}

.gitignore

@@ -0,0 +1,9 @@
+venv/
+build/
+dist/
+__pycache__/
+pyvenv.cfg
+.env/
+bin/
+lib/
+.idea/

.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+ci:
+  skip:
+    - unittest
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: check-yaml
+    -   id: check-added-large-files
+-   repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+    -   id: black
+-   repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+    -   id: isort
+        name: isort (python)
+
+-   repo: local
+    hooks:
+    -   id: unittest
+        name: unittest
+        entry: python -m unittest discover
+        language: system
+        'types': [python]
+        args: ["-p '*test.py'"] # Probably this option is absolutely not needed.
+        pass_filenames: false

.readthedocs.yaml

@@ -0,0 +1,20 @@
+# .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"
+
+mkdocs:
+  configuration: mkdocs.yml
+
+# Optionally declare the Python requirements required to build your docs
+python:
+   install:
+   - requirements: docs/requirements.txt

API/__init__.py

@@ -1,201 +0,0 @@
-import asyncio
-import json
-import ipaddress
-import warnings
-import logging
-
-
-class APIError(Exception):
-    def __init__(self, *args):
-        if args:
-            self.message = args[0]
-        else:
-            self.message = None
-
-    def __str__(self):
-        if self.message:
-            return f"{self.message}"
-        else:
-            return "Incorrect API parameters."
-
-
-class APIWarning(Warning):
-    def __init__(self, *args):
-        if args:
-            self.message = args[0]
-        else:
-            self.message = None
-
-    def __str__(self):
-        if self.message:
-            return f"{self.message}"
-        else:
-            return "Incorrect API parameters."
-
-
-class BaseMinerAPI:
-    def __init__(self, ip: str, port: int = 4028) -> None:
-        # api port, should be 4028
-        self.port = port
-        # ip address of the miner
-        self.ip = ipaddress.ip_address(ip)
-
-    def get_commands(self) -> list:
-        """Get a list of command accessible to a specific type of API on the miner."""
-        return [
-            func
-            for func in
-            # each function in self
-            dir(self)
-            if callable(getattr(self, func)) and
-            # no __ methods
-            not func.startswith("__") and
-            # remove all functions that are in this base class
-            func
-            not in [
-                func
-                for func in dir(BaseMinerAPI)
-                if callable(getattr(BaseMinerAPI, func))
-            ]
-        ]
-
-    async def multicommand(self, *commands: str) -> dict:
-        """Creates and sends multiple commands as one command to the miner."""
-        logging.debug(f"{self.ip}: Sending multicommand: {[*commands]}")
-        # split the commands into a proper list
-        user_commands = [*commands]
-        allowed_commands = self.get_commands()
-        # make sure we can actually run the command, otherwise it will fail
-        commands = [command for command in user_commands if command in allowed_commands]
-        for item in list(set(user_commands) - set(commands)):
-            warnings.warn(
-                f"""Removing incorrect command: {item}
-If you are sure you want to use this command please use API.send_command("{item}", ignore_errors=True) instead.""",
-                APIWarning,
-            )
-        # standard multicommand format is "command1+command2"
-        # doesnt work for S19 which is dealt with in the send command function
-        command = "+".join(commands)
-        data = None
-        try:
-            data = await self.send_command(command)
-        except APIError as e:
-            try:
-                data = {}
-                # S19 handler, try again
-                for cmd in command.split("+"):
-                    data[cmd] = []
-                    data[cmd].append(await self.send_command(cmd))
-            except APIError as e:
-                raise APIError(e)
-            except Exception as e:
-                logging.warning(f"{self.ip}: API Multicommand Error: {e}")
-        if data:
-            logging.debug(f"{self.ip}: Received multicommand data.")
-            return data
-
-    async def send_command(
-        self,
-        command: str,
-        parameters: str or int or bool = None,
-        ignore_errors: bool = False,
-    ) -> dict:
-        """Send an API command to the miner and return the result."""
-        try:
-            # get reader and writer streams
-            reader, writer = await asyncio.open_connection(str(self.ip), self.port)
-        # handle OSError 121
-        except OSError as e:
-            if e.winerror == "121":
-                logging.warning("Semaphore Timeout has Expired.")
-            return {}
-
-        # create the command
-        cmd = {"command": command}
-        if parameters is not None:
-            cmd["parameter"] = parameters
-
-        # send the command
-        writer.write(json.dumps(cmd).encode("utf-8"))
-        await writer.drain()
-
-        # instantiate data
-        data = b""
-
-        # loop to receive all the data
-        try:
-            while True:
-                d = await reader.read(4096)
-                if not d:
-                    break
-                data += d
-        except Exception as e:
-            logging.warning(f"{self.ip}: API Command Error: {e}")
-
-        data = self.load_api_data(data)
-
-        # close the connection
-        writer.close()
-        await writer.wait_closed()
-
-        # check for if the user wants to allow errors to return
-        if not ignore_errors:
-            # validate the command succeeded
-            validation = self.validate_command_output(data)
-            if not validation[0]:
-                logging.warning(f"{self.ip}: API Command Error: {validation[1]}")
-                raise APIError(validation[1])
-
-        return data
-
-    @staticmethod
-    def validate_command_output(data: dict) -> tuple:
-        """Check if the returned command output is correctly formatted."""
-        # check if the data returned is correct or an error
-        # if status isn't a key, it is a multicommand
-        if "STATUS" not in data.keys():
-            for key in data.keys():
-                # make sure not to try to turn id into a dict
-                if not key == "id":
-                    # make sure they succeeded
-                    if "STATUS" in data[key][0].keys():
-                        if data[key][0]["STATUS"][0]["STATUS"] not in ["S", "I"]:
-                            # this is an error
-                            return False, f"{key}: " + data[key][0]["STATUS"][0]["Msg"]
-        elif "id" not in data.keys():
-            if data["STATUS"] not in ["S", "I"]:
-                return False, data["Msg"]
-        else:
-            # make sure the command succeeded
-            if data["STATUS"][0]["STATUS"] not in ("S", "I"):
-                # this is an error
-                if data["STATUS"][0]["STATUS"] not in ("S", "I"):
-                    return False, data["STATUS"][0]["Msg"]
-        return True, None
-
-    @staticmethod
-    def load_api_data(data: bytes) -> dict:
-        """Convert API data from JSON to dict"""
-        str_data = None
-        try:
-            # some json from the API returns with a null byte (\x00) on the end
-            if data.endswith(b"\x00"):
-                # handle the null byte
-                str_data = data.decode("utf-8")[:-1]
-            else:
-                # no null byte
-                str_data = data.decode("utf-8")
-            # fix an error with a btminer return having an extra comma that breaks json.loads()
-            str_data = str_data.replace(",}", "}")
-            # fix an error with a btminer return having a newline that breaks json.loads()
-            str_data = str_data.replace("\n", "")
-            # fix an error with a bmminer return not having a specific comma that breaks json.loads()
-            str_data = str_data.replace("}{", "},{")
-            # fix an error with a bmminer return  having a specific comma that breaks json.loads()
-            str_data = str_data.replace("[,{", "[{")
-            # parse the json
-            parsed_data = json.loads(str_data)
-        # handle bad json
-        except json.decoder.JSONDecodeError as e:
-            raise APIError(f"Decode Error {e}: {str_data}")
-        return parsed_data

API/bmminer.py

@@ -1,493 +0,0 @@
-from API import BaseMinerAPI
-
-
-class BMMinerAPI(BaseMinerAPI):
-    """An abstraction of the BMMiner API.
-
-    Each method corresponds to an API command in BMMiner.
-
-    BMMiner API documentation:
-        https://github.com/jameshilliard/bmminer/blob/master/API-README
-
-    This class abstracts use of the BMMiner API, as well as the
-    methods for sending commands to it.  The self.send_command()
-    function handles sending a command to the miner asynchronously, and
-    as such is the base for many of the functions in this class, which
-    rely on it to send the command for them.
-
-    :param ip: The IP of the miner to reference the API on.
-    :param port: The port to reference the API on.  Default is 4028.
-    """
-
-    def __init__(self, ip: str, port: int = 4028) -> None:
-        super().__init__(ip, port)
-
-    async def version(self) -> dict:
-        """Get miner version info.
-
-        :return: Miner version information.
-        """
-        return await self.send_command("version")
-
-    async def config(self) -> dict:
-        """Get some basic configuration info.
-
-        :return: Some miner configuration information:
-            ASC Count <- the number of ASCs
-            PGA Count <- the number of PGAs
-            Pool Count <- the number of Pools
-            Strategy <- the current pool strategy
-            Log Interval <- the interval of logging
-            Device Code <- list of compiled device drivers
-            OS <- the current operating system
-            Failover-Only <- failover-only setting
-            Scan Time <- scan-time setting
-            Queue <- queue setting
-            Expiry <- expiry setting
-        """
-        return await self.send_command("config")
-
-    async def summary(self) -> dict:
-        """Get the status summary of the miner.
-
-        :return: The status summary of the miner.
-        """
-        return await self.send_command("summary")
-
-    async def pools(self) -> dict:
-        """Get pool information.
-
-        :return: Miner pool information.
-        """
-        return await self.send_command("pools")
-
-    async def devs(self) -> dict:
-        """Get data on each PGA/ASC with their details.
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        return await self.send_command("devs")
-
-    async def edevs(self, old: bool = False) -> dict:
-        """Get data on each PGA/ASC with their details, ignoring
-         blacklisted and zombie devices.
-
-        :param old: Include zombie devices that became zombies less
-        than 'old' seconds ago
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        if old:
-            return await self.send_command("edevs", parameters=old)
-        else:
-            return await self.send_command("edevs")
-
-    async def pga(self, n: int) -> dict:
-        """Get data from PGA n.
-
-        :param n: The PGA number to get data from.
-
-        :return: Data on the PGA n.
-        """
-        return await self.send_command("pga", parameters=n)
-
-    async def pgacount(self) -> dict:
-        """Get data fon all PGAs.
-
-        :return: Data on the PGAs connected.
-        """
-        return await self.send_command("pgacount")
-
-    async def switchpool(self, n: int) -> dict:
-        """Switch pools to pool n.
-
-        :param n: The pool to switch to.
-
-        :return: A confirmation of switching to pool n.
-        """
-        return await self.send_command("switchpool", parameters=n)
-
-    async def enablepool(self, n: int) -> dict:
-        """Enable pool n.
-
-        :param n: The pool to enable.
-
-        :return: A confirmation of enabling pool n.
-        """
-        return await self.send_command("enablepool", parameters=n)
-
-    async def addpool(self, url: str, username: str, password: str) -> dict:
-        """Add a pool to the miner.
-
-        :param url: The URL of the new pool to add.
-        :param username: The users username on the new pool.
-        :param password: The worker password on the new pool.
-
-        :return: A confirmation of adding the pool.
-        """
-        return await self.send_command(
-            "addpool", parameters=f"{url}, " f"{username}, " f"{password}"
-        )
-
-    async def poolpriority(self, *n: int) -> dict:
-        """Set pool priority.
-
-        :param n: Pools in order of priority.
-
-        :return: A confirmation of setting pool priority.
-        """
-        pools = f"{','.join([str(item) for item in n])}"
-        return await self.send_command("poolpriority", parameters=pools)
-
-    async def poolquota(self, n: int, q: int) -> dict:
-        """Set pool quota.
-
-        :param n: Pool number to set quota on.
-        :param q: Quota to set the pool to.
-
-        :return: A confirmation of setting pool quota.
-        """
-        return await self.send_command("poolquota", parameters=f"{n}, " f"{q}")
-
-    async def disablepool(self, n: int) -> dict:
-        """Disable a pool.
-
-        :param n: Pool to disable.
-
-        :return: A confirmation of diabling the pool.
-        """
-        return await self.send_command("disablepool", parameters=n)
-
-    async def removepool(self, n: int) -> dict:
-        """Remove a pool.
-
-        :param n: Pool to remove.
-
-        :return: A confirmation of removing the pool.
-        """
-        return await self.send_command("removepool", parameters=n)
-
-    async def save(self, filename: str = None) -> dict:
-        """Save the config.
-
-        :param filename: Filename to save the config as.
-
-        :return: A confirmation of saving the config.
-        """
-        if filename:
-            return await self.send_command("save", parameters=filename)
-        else:
-            return await self.send_command("save")
-
-    async def quit(self) -> dict:
-        """Quit BMMiner.
-
-        :return: A single "BYE" before BMMiner quits.
-        """
-        return await self.send_command("quit")
-
-    async def notify(self) -> dict:
-        """Notify the user of past errors.
-
-        :return: The last status and count of each devices problem(s).
-        """
-        return await self.send_command("notify")
-
-    async def privileged(self) -> dict:
-        """Check if you have privileged access.
-
-        :return: The STATUS section with an error if you have no
-        privileged access, or success if you have privileged access.
-        """
-        return await self.send_command("privileged")
-
-    async def pgaenable(self, n: int) -> dict:
-        """Enable PGA n.
-
-        :param n: The PGA to enable.
-
-        :return: A confirmation of enabling PGA n.
-        """
-        return await self.send_command("pgaenable", parameters=n)
-
-    async def pgadisable(self, n: int) -> dict:
-        """Disable PGA n.
-
-        :param n: The PGA to disable.
-
-        :return: A confirmation of disabling PGA n.
-        """
-        return await self.send_command("pgadisable", parameters=n)
-
-    async def pgaidentify(self, n: int) -> dict:
-        """Identify PGA n.
-
-        :param n: The PGA to identify.
-
-        :return: A confirmation of identifying PGA n.
-        """
-        return await self.send_command("pgaidentify", parameters=n)
-
-    async def devdetails(self) -> dict:
-        """Get data on all devices with their static details.
-
-        :return: Data on all devices with their static details.
-        """
-        return await self.send_command("devdetails")
-
-    async def restart(self) -> dict:
-        """Restart BMMiner using the API.
-
-        :return: A reply informing of the restart.
-        """
-        return await self.send_command("restart")
-
-    async def stats(self) -> dict:
-        """Get stats of each device/pool with more than 1 getwork.
-
-        :return: Stats of each device/pool with more than 1 getwork.
-        """
-        return await self.send_command("stats")
-
-    async def estats(self, old: bool = False) -> dict:
-        """Get stats of each device/pool with more than 1 getwork,
-        ignoring zombie devices.
-
-        :param old: Include zombie devices that became zombies less
-        than 'old' seconds ago.
-
-        :return: Stats of each device/pool with more than 1 getwork,
-        ignoring zombie devices.
-        """
-        if old:
-            return await self.send_command("estats", parameters=old)
-        else:
-            return await self.send_command("estats")
-
-    async def check(self, command: str) -> dict:
-        """Check if the command command exists in BMMiner.
-
-        :param command: The command to check.
-
-        :return: Information about a command:
-            Exists (Y/N) <- the command exists in this version
-            Access (Y/N) <- you have access to use the command
-        """
-        return await self.send_command("check", parameters=command)
-
-    async def failover_only(self, failover: bool) -> dict:
-        """Set failover-only.
-
-
-        :param failover: What to set failover-only to.
-
-        :return: Confirmation of setting failover-only.
-        """
-        return await self.send_command("failover-only", parameters=failover)
-
-    async def coin(self) -> dict:
-        """Get information on the current coin.
-
-        :return: Information about the current coin being mined:
-            Hash Method <- the hashing algorithm
-            Current Block Time <- blocktime as a float, 0 means none
-            Current Block Hash <- the hash of the current block, blank
-            means none
-            LP <- whether LP is in use on at least 1 pool
-            Network Difficulty: the current network difficulty
-        """
-        return await self.send_command("coin")
-
-    async def debug(self, setting: str) -> dict:
-        """Set a debug setting.
-
-        :param setting: Which setting to switch to. Options are:
-                Silent,
-                Quiet,
-                Verbose,
-                Debug,
-                RPCProto,
-                PerDevice,
-                WorkTime,
-                Normal.
-
-        :return: Data on which debug setting was enabled or disabled.
-        """
-        return await self.send_command("debug", parameters=setting)
-
-    async def setconfig(self, name: str, n: int) -> dict:
-        """Set config of name to value n.
-
-        :param name: The name of the config setting to set. Options are:
-                queue,
-                scantime,
-                expiry.
-        :param n: The value to set the 'name' setting to.
-
-        :return: The results of setting config of name to n.
-        """
-        return await self.send_command("setconfig", parameters=f"{name}, " f"{n}")
-
-    async def usbstats(self) -> dict:
-        """Get stats of all USB devices except ztex.
-
-        :return: The stats of all USB devices except ztex.
-        """
-        return await self.send_command("usbstats")
-
-    async def pgaset(self, n: int, opt: str, val: int = None) -> dict:
-        """Set PGA option opt to val on PGA n.
-
-        Options:
-            MMQ -
-                opt: clock
-                val: 160 - 230 (multiple of 2)
-            CMR -
-                opt: clock
-                val: 100 - 220
-
-        :param n: The PGA to set the options on.
-        :param opt: The option to set. Setting this to 'help'
-        returns a help message.
-        :param val: The value to set the option to.
-
-        :return: Confirmation of setting PGA n with opt[,val].
-        """
-        if val:
-            return await self.send_command(
-                "pgaset", parameters=f"{n}, " f"{opt}, " f"{val}"
-            )
-        else:
-            return await self.send_command("pgaset", parameters=f"{n}, " f"{opt}")
-
-    async def zero(self, which: str, summary: bool) -> dict:
-        """Zero a device.
-
-        :param which: Which device to zero.
-            Setting this to 'all' zeros all devices.
-            Setting this to 'bestshare' zeros only the bestshare  values
-            for each pool and global.
-        :param summary: Whether or not to show a full summary.
-
-
-        :return: the STATUS section with info on the zero and optional
-        summary.
-        """
-        return await self.send_command("zero", parameters=f"{which}, {summary}")
-
-    async def hotplug(self, n: int) -> dict:
-        """Enable hotplug.
-
-        :param n: The device number to set hotplug on.
-
-        :return: Information on hotplug status.
-        """
-        return await self.send_command("hotplug", parameters=n)
-
-    async def asc(self, n: int) -> dict:
-        """Get data for ASC device n.
-
-        :param n: The device to get data for.
-
-        :return: The data for ASC device n.
-        """
-        return await self.send_command("asc", parameters=n)
-
-    async def ascenable(self, n: int) -> dict:
-        """Enable ASC device n.
-
-        :param n: The device to enable.
-
-        :return: Confirmation of enabling ASC device n.
-        """
-        return await self.send_command("ascenable", parameters=n)
-
-    async def ascdisable(self, n: int) -> dict:
-        """Disable ASC device n.
-
-        :param n: The device to disable.
-
-        :return: Confirmation of disabling ASC device n.
-        """
-        return await self.send_command("ascdisable", parameters=n)
-
-    async def ascidentify(self, n: int) -> dict:
-        """Identify ASC device n.
-
-        :param n: The device to identify.
-
-        :return: Confirmation of identifying ASC device n.
-        """
-        return await self.send_command("ascidentify", parameters=n)
-
-    async def asccount(self) -> dict:
-        """Get data on the number of ASC devices and their info.
-
-        :return: Data on all ASC devices.
-        """
-        return await self.send_command("asccount")
-
-    async def ascset(self, n: int, opt: str, val: int = None) -> dict:
-        """Set ASC n option opt to value val.
-
-        Sets an option on the ASC n to a value.  Allowed options are:
-            AVA+BTB -
-                opt: freq
-                val: 256 - 1024 (chip frequency)
-            BTB -
-                opt: millivolts
-                val: 1000 - 1400 (core voltage)
-            MBA -
-                opt: reset
-                val: 0 - # of chips (reset a chip)
-
-                opt: freq
-                val: 0 - # of chips, 100 - 1400 (chip frequency)
-
-                opt: ledcount
-                val: 0 - 100 (chip count for LED)
-
-                opt: ledlimit
-                val: 0 - 200 (LED off below GH/s)
-
-                opt: spidelay
-                val: 0 - 9999 (SPI per I/O delay)
-
-                opt: spireset
-                val: i or s, 0 - 9999 (SPI regular reset)
-
-                opt: spisleep
-                val: 0 - 9999 (SPI reset sleep in ms)
-            BMA -
-                opt: volt
-                val: 0 - 9
-
-                opt: clock
-                val: 0 - 15
-
-
-        :param n: The ASC to set the options on.
-        :param opt: The option to set. Setting this to 'help' returns a
-        help message.
-        :param val: The value to set the option to.
-
-        :return: Confirmation of setting option opt to value val.
-        """
-        if val:
-            return await self.send_command("ascset", parameters=f"{n}, {opt}, {val}")
-        else:
-            return await self.send_command("ascset", parameters=f"{n}, {opt}")
-
-    async def lcd(self) -> dict:
-        """Get a general all-in-one status summary of the miner.
-
-        :return: An all-in-one status summary of the miner.
-        """
-        return await self.send_command("lcd")
-
-    async def lockstats(self) -> dict:
-        """Write lockstats to STDERR.
-
-        :return: The result of writing the lock stats to STDERR.
-        """
-        return await self.send_command("lockstats")

API/bosminer.py

@@ -1,208 +0,0 @@
-from API import BaseMinerAPI
-
-
-class BOSMinerAPI(BaseMinerAPI):
-    """An abstraction of the BOSMiner API.
-
-    Each method corresponds to an API command in BOSMiner.
-
-    BOSMiner API documentation:
-        https://docs.braiins.com/os/plus-en/Development/1_api.html
-
-    This class abstracts use of the BOSMiner API, as well as the
-    methods for sending commands to it.  The self.send_command()
-    function handles sending a command to the miner asynchronously, and
-    as such is the base for many of the functions in this class, which
-    rely on it to send the command for them.
-
-    :param ip: The IP of the miner to reference the API on.
-    :param port: The port to reference the API on.  Default is 4028.
-    """
-
-    def __init__(self, ip, port=4028):
-        super().__init__(ip, port)
-
-    async def asccount(self) -> dict:
-        """Get data on the number of ASC devices and their info.
-
-        :return: Data on all ASC devices.
-        """
-        return await self.send_command("asccount")
-
-    async def asc(self, n: int) -> dict:
-        """Get data for ASC device n.
-
-        :param n: The device to get data for.
-
-        :return: The data for ASC device n.
-        """
-        return await self.send_command("asc", parameters=n)
-
-    async def devdetails(self) -> dict:
-        """Get data on all devices with their static details.
-
-        :return: Data on all devices with their static details.
-        """
-        return await self.send_command("devdetails")
-
-    async def devs(self) -> dict:
-        """Get data on each PGA/ASC with their details.
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        return await self.send_command("devs")
-
-    async def edevs(self, old: bool = False) -> dict:
-        """Get data on each PGA/ASC with their details, ignoring
-         blacklisted and zombie devices.
-
-        :param old: Include zombie devices that became zombies less
-        than 'old' seconds ago
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        if old:
-            return await self.send_command("edevs", parameters="old")
-        else:
-            return await self.send_command("edevs")
-
-    async def pools(self) -> dict:
-        """Get pool information.
-
-        :return: Miner pool information.
-        """
-        return await self.send_command("pools")
-
-    async def summary(self) -> dict:
-        """Get the status summary of the miner.
-
-        :return: The status summary of the miner.
-        """
-        return await self.send_command("summary")
-
-    async def stats(self) -> dict:
-        """Get stats of each device/pool with more than 1 getwork.
-
-        :return: Stats of each device/pool with more than 1 getwork.
-        """
-        return await self.send_command("stats")
-
-    async def version(self) -> dict:
-        """Get miner version info.
-
-        :return: Miner version information.
-        """
-        return await self.send_command("version")
-
-    async def estats(self, old: bool = False) -> dict:
-        """Get stats of each device/pool with more than 1 getwork,
-        ignoring zombie devices.
-
-        :param old: Include zombie devices that became zombies less
-        than 'old' seconds ago.
-
-        :return: Stats of each device/pool with more than 1 getwork,
-        ignoring zombie devices.
-        """
-        if old:
-            return await self.send_command("estats", parameters=old)
-        else:
-            return await self.send_command("estats")
-
-    async def check(self, command: str) -> dict:
-        """Check if the command command exists in BOSMiner.
-
-        :param command: The command to check.
-
-        :return: Information about a command:
-            Exists (Y/N) <- the command exists in this version
-            Access (Y/N) <- you have access to use the command
-        """
-        return await self.send_command("check", parameters=command)
-
-    async def coin(self) -> dict:
-        """Get information on the current coin.
-
-        :return: Information about the current coin being mined:
-            Hash Method <- the hashing algorithm
-            Current Block Time <- blocktime as a float, 0 means none
-            Current Block Hash <- the hash of the current block, blank
-            means none
-            LP <- whether LP is in use on at least 1 pool
-            Network Difficulty: the current network difficulty
-        """
-        return await self.send_command("coin")
-
-    async def lcd(self) -> dict:
-        """Get a general all-in-one status summary of the miner.
-
-        :return: An all-in-one status summary of the miner.
-        """
-        return await self.send_command("lcd")
-
-    async def switchpool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("switchpool", parameters=n)
-
-    async def enablepool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("enablepool", parameters=n)
-
-    async def disablepool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("disablepool", parameters=n)
-
-    async def addpool(self, url: str, username: str, password: str) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("addpool", parameters=f"{url}, {username}, {password}")
-
-    async def removepool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("removepool", parameters=n)
-
-    async def fans(self) -> dict:
-        """Get fan data.
-
-        :return: Data on the fans of the miner.
-        """
-        return await self.send_command("fans")
-
-    async def tempctrl(self) -> dict:
-        """Get temperature control data.
-
-        :return: Data about the temp control settings of the miner.
-        """
-        return await self.send_command("tempctrl")
-
-    async def temps(self) -> dict:
-        """Get temperature data.
-
-        :return: Data on the temps of the miner.
-        """
-        return await self.send_command("temps")
-
-    async def tunerstatus(self) -> dict:
-        """Get tuner status data
-
-        :return: Data on the status of autotuning.
-        """
-        return await self.send_command("tunerstatus")
-
-    async def pause(self) -> dict:
-        """Pause mining.
-
-        :return: Confirmation of pausing mining.
-        """
-        return await self.send_command("pause")
-
-    async def resume(self) -> dict:
-        """Resume mining.
-
-        :return: Confirmation of resuming mining.
-        """
-        return await self.send_command("resume")

API/btminer.py

@@ -1,704 +0,0 @@
-import asyncio
-import re
-import json
-import hashlib
-import binascii
-import base64
-import logging
-
-from passlib.handlers.md5_crypt import md5_crypt
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-
-from API import BaseMinerAPI, APIError
-from settings import WHATSMINER_PWD
-
-
-### IMPORTANT ###
-# you need to change the password of the miners using the Whatsminer
-# tool, then you can set them back to admin with this tool, but they
-# must be changed to something else and set back to admin with this
-# or the privileged API will not work using admin as the password.  If
-# you change the password, you can pass that to the this class as pwd,
-# or add it as the Whatsminer_pwd in the settings.toml file.
-
-
-def _crypt(word: str, salt: str) -> str:
-    """Encrypts a word with a salt, using a standard salt format.
-
-    Encrypts a word using a salt with the format
-    '\s*\$(\d+)\$([\w\./]*)\$'.  If this format is not used, a
-    ValueError is raised.
-
-    :param word: The word to be encrypted.
-    :param salt: The salt to encrypt the word.
-    :return: An MD5 hash of the word with the salt.
-    """
-    # compile a standard format for the salt
-    standard_salt = re.compile("\s*\$(\d+)\$([\w\./]*)\$")
-    # check if the salt matches
-    match = standard_salt.match(salt)
-    # if the matching fails, the salt is incorrect
-    if not match:
-        raise ValueError("Salt format is not correct.")
-    # save the matched salt in a new variable
-    new_salt = match.group(2)
-    # encrypt the word with the salt using md5
-    result = md5_crypt.hash(word, salt=new_salt)
-    return result
-
-
-def _add_to_16(string: str) -> bytes:
-    """Add null bytes to a string until the length is a multiple 16
-
-    :param string: The string to lengthen to a multiple of 16 and
-    encode.
-
-    :return: The input string as bytes with a multiple of 16 as the
-    length.
-    """
-    while len(string) % 16 != 0:
-        string += "\0"
-    return str.encode(string)  # return bytes
-
-
-def parse_btminer_priviledge_data(token_data: dict, data: dict):
-    """Parses data returned from the BTMiner privileged API.
-
-    Parses data from the BTMiner privileged API using the the token
-    from the API in an AES format.
-
-    :param token_data: The token information from self.get_token().
-    :param data: The data to parse, returned from the API.
-
-    :return: A decoded dict version of the privileged command output.
-    """
-    # get the encoded data from the dict
-    enc_data = data["enc"]
-    # get the aes key from the token data
-    aeskey = hashlib.sha256(token_data["host_passwd_md5"].encode()).hexdigest()
-    # unhexlify the aes key
-    aeskey = binascii.unhexlify(aeskey.encode())
-    # create the required decryptor
-    aes = Cipher(algorithms.AES(aeskey), modes.ECB())
-    decryptor = aes.decryptor()
-    # decode the message with the decryptor
-    ret_msg = json.loads(
-        decryptor.update(base64.decodebytes(bytes(enc_data, encoding="utf8")))
-        .rstrip(b"\0")
-        .decode("utf8")
-    )
-    return ret_msg
-
-
-def create_privileged_cmd(token_data: dict, command: dict) -> bytes:
-    """Create a privileged command to send to the BTMiner API.
-
-    Creates a privileged command using the token from the API and the
-    command as a dict of {'command': cmd}, with cmd being any command
-    that the miner API accepts.
-
-    :param token_data: The token information from self.get_token().
-    :param command: The command to turn into a privileged command.
-
-    :return: The encrypted privileged command to be sent to the miner.
-    """
-    # add token to command
-    command["token"] = token_data["host_sign"]
-    # encode host_passwd data and get hexdigest
-    aeskey = hashlib.sha256(token_data["host_passwd_md5"].encode()).hexdigest()
-    # unhexlify the encoded host_passwd
-    aeskey = binascii.unhexlify(aeskey.encode())
-    # create a new AES key
-    aes = Cipher(algorithms.AES(aeskey), modes.ECB())
-    encryptor = aes.encryptor()
-    # dump the command to json
-    api_json_str = json.dumps(command)
-    # encode the json command with the aes key
-    api_json_str_enc = (
-        base64.encodebytes(encryptor.update(_add_to_16(api_json_str)))
-        .decode("utf-8")
-        .replace("\n", "")
-    )
-    # label the data as being encoded
-    data_enc = {"enc": 1, "data": api_json_str_enc}
-    # dump the labeled data to json
-    api_packet_str = json.dumps(data_enc)
-    return api_packet_str.encode("utf-8")
-
-
-class BTMinerAPI(BaseMinerAPI):
-    """An abstraction of the API for MicroBT Whatsminers, BTMiner.
-
-    Each method corresponds to an API command in BMMiner.
-
-    This class abstracts use of the BTMiner API, as well as the
-    methods for sending commands to it.  The self.send_command()
-    function handles sending a command to the miner asynchronously, and
-    as such is the base for many of the functions in this class, which
-    rely on it to send the command for them.
-
-    All privileged commands for BTMiner's API require that you change
-    the password of the miners using the Whatsminer tool, and it can be
-    changed back to admin with this tool after.  Set the new password
-    either by passing it to the __init__ method, or changing it in
-    settings.toml.
-
-    Additionally, the API commands for the privileged API must be
-    encoded using a token from the miner, all privileged commands do
-    this automatically for you and will decode the output to look like
-    a normal output from a miner API.
-
-    :param ip: The IP of the miner to reference the API on.
-    :param port: The port to reference the API on.  Default is 4028.
-    :param pwd: The admin password of the miner.  Default is admin.
-    """
-
-    def __init__(self, ip, port=4028, pwd: str = WHATSMINER_PWD):
-        super().__init__(ip, port)
-        self.admin_pwd = pwd
-        self.current_token = None
-
-    async def send_command(
-        self,
-        command: str or bytes,
-        parameters: str or int or bool = None,
-        ignore_errors: bool = False,
-    ) -> dict:
-        """Send a command to the miner API.
-
-        Send a command using an asynchronous connection, load the data,
-        parse encoded data if needed, and return the result.
-
-        :param command: The command to send to the miner.
-        :param parameters: Parameters to pass to the command.
-        :param ignore_errors: Ignore the E (Error) status code from the
-        API.
-
-        :return: The data received from the API after sending the
-        command.
-        """
-        # check if command is a string
-        # if its bytes its encoded and needs to be sent raw
-        if isinstance(command, str):
-            # if it is a string, put it into the standard command format
-            command = json.dumps({"command": command}).encode("utf-8")
-        try:
-            # get reader and writer streams
-            reader, writer = await asyncio.open_connection(str(self.ip), self.port)
-        # handle OSError 121
-        except OSError as e:
-            if e.winerror == "121":
-                print("Semaphore Timeout has Expired.")
-            return {}
-
-        # send the command
-        writer.write(command)
-        await writer.drain()
-
-        # instantiate data
-        data = b""
-
-        # loop to receive all the data
-        try:
-            while True:
-                d = await reader.read(4096)
-                if not d:
-                    break
-                data += d
-        except Exception as e:
-            logging.info(f"{str(self.ip)}: {e}")
-
-        data = self.load_api_data(data)
-
-        # close the connection
-        writer.close()
-        await writer.wait_closed()
-
-        # check if the returned data is encoded
-        if "enc" in data.keys():
-            # try to parse the encoded data
-            try:
-                data = parse_btminer_priviledge_data(self.current_token, data)
-            except Exception as e:
-                logging.info(f"{str(self.ip)}: {e}")
-
-        if not ignore_errors:
-            # if it fails to validate, it is likely an error
-            validation = self.validate_command_output(data)
-            if not validation[0]:
-                raise APIError(validation[1])
-
-        # return the parsed json as a dict
-        return data
-
-    async def get_token(self):
-        """Gets token information from the API.
-
-        :return: An encoded token and md5 password, which are used
-        for the privileged API.
-        """
-        # get the token
-        data = await self.send_command("get_token")
-
-        # encrypt the admin password with the salt
-        pwd = _crypt(self.admin_pwd, "$1$" + data["Msg"]["salt"] + "$")
-        pwd = pwd.split("$")
-
-        # take the 4th item from the pwd split
-        host_passwd_md5 = pwd[3]
-
-        # encrypt the pwd with the time and new salt
-        tmp = _crypt(pwd[3] + data["Msg"]["time"], "$1$" + data["Msg"]["newsalt"] + "$")
-        tmp = tmp.split("$")
-
-        # take the 4th item from the encrypted pwd split
-        host_sign = tmp[3]
-
-        # set the current token
-        self.current_token = {
-            "host_sign": host_sign,
-            "host_passwd_md5": host_passwd_md5,
-        }
-        return self.current_token
-
-    #### PRIVILEGED COMMANDS ####
-    # Please read the top of this file to learn
-    # how to configure the Whatsminer API to
-    # use these commands.
-
-    async def update_pools(
-        self,
-        pool_1: str,
-        worker_1: str,
-        passwd_1: str,
-        pool_2: str = None,
-        worker_2: str = None,
-        passwd_2: str = None,
-        pool_3: str = None,
-        worker_3: str = None,
-        passwd_3: str = None,
-    ):
-        """Update the pools of the miner using the API.
-
-        Update the pools of the miner using the API, only works after
-        changing the password of the miner using the Whatsminer tool.
-
-        :param pool_1: The URL to update pool 1 to.
-        :param worker_1: The worker name for pool 1 to update to.
-        :param passwd_1: The password for pool 1 to update to.
-        :param pool_2: The URL to update pool 2 to.
-        :param worker_2: The worker name for pool 2 to update to.
-        :param passwd_2: The password for pool 2 to update to.
-        :param pool_3: The URL to update pool 3 to.
-        :param worker_3: The worker name for pool 3 to update to.
-        :param passwd_3: The password for pool 3 to update to.
-        :return: A dict from the API to confirm the pools were updated.
-        """
-        # get the token and password from the miner
-        token_data = await self.get_token()
-
-        # parse pool data
-        if not pool_1:
-            raise APIError("No pools set.")
-        elif pool_2 and pool_3:
-            command = {
-                "cmd": "update_pools",
-                "pool1": pool_1,
-                "worker1": worker_1,
-                "passwd1": passwd_1,
-                "pool2": pool_2,
-                "worker2": worker_2,
-                "passwd2": passwd_2,
-                "pool3": pool_3,
-                "worker3": worker_3,
-                "passwd3": passwd_3,
-            }
-        elif pool_2:
-            command = {
-                "cmd": "update_pools",
-                "pool1": pool_1,
-                "worker1": worker_1,
-                "passwd1": passwd_1,
-                "pool2": pool_2,
-                "worker2": worker_2,
-                "passwd2": passwd_2,
-            }
-        else:
-            command = {
-                "cmd": "update_pools",
-                "pool1": pool_1,
-                "worker1": worker_1,
-                "passwd1": passwd_1,
-            }
-        # encode the command with the token data
-        enc_command = create_privileged_cmd(token_data, command)
-        # send the command
-        return await self.send_command(enc_command)
-
-    async def restart(self):
-        """Restart BTMiner using the API.
-
-        Restart BTMiner using the API, only works after changing
-        the password of the miner using the Whatsminer tool.
-
-        :return: A reply informing of the restart.
-        """
-        command = {"cmd": "restart_btminer"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def power_off(self, respbefore: bool = True):
-        """Power off the miner using the API.
-
-        Power off the miner using the API, only works after changing
-        the password of the miner using the Whatsminer tool.
-
-        :param respbefore: Whether to respond before powering off.
-        :return: A reply informing of the status of powering off.
-        """
-        if respbefore:
-            command = {"cmd": "power_off", "respbefore": "true"}
-        else:
-            command = {"cmd": "power_off", "respbefore": "false"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def power_on(self):
-        """Power on the miner using the API.
-
-        Power on the miner using the API, only works after changing
-        the password of the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of powering on.
-        """
-        command = {"cmd": "power_on"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def reset_led(self):
-        """Reset the LED on the miner using the API.
-
-        Reset the LED on the miner using the API, only works after
-        changing the password of the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of resetting the LED.
-        """
-        command = {"cmd": "set_led", "param": "auto"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def set_led(
-        self,
-        color: str = "red",
-        period: int = 2000,
-        duration: int = 1000,
-        start: int = 0,
-    ):
-        """Set the LED on the miner using the API.
-
-        Set the LED on the miner using the API, only works after
-        changing the password of the miner using the Whatsminer tool.
-
-        :param color: The LED color to set, either 'red' or 'green'.
-        :param period: The flash cycle in ms.
-        :param duration: LED on time in the cycle in ms.
-        :param start: LED on time offset in the cycle in ms.
-        :return: A reply informing of the status of setting the LED.
-        """
-        command = {
-            "cmd": "set_led",
-            "color": color,
-            "period": period,
-            "duration": duration,
-            "start": start,
-        }
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def set_low_power(self):
-        """Set low power mode on the miner using the API.
-
-        Set low power mode on the miner using the API, only works after
-        changing the password of the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of setting low power
-        mode.
-        """
-        command = {"cmd": "set_low_power"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def update_firmware(self):
-        # to be determined if this will be added later
-        # requires a file stream in bytes
-        return NotImplementedError
-
-    async def reboot(self):
-        """Reboot the miner using the API.
-
-        :return: A reply informing of the status of the reboot.
-        """
-        command = {"cmd": "reboot"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def factory_reset(self):
-        """Reset the miner to factory defaults.
-
-        :return: A reply informing of the status of the reset.
-        """
-        command = {"cmd": "factory_reset"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def update_pwd(self, old_pwd: str, new_pwd: str):
-        """Update the admin user's password.
-
-        Update the admin user's password, only works after changing the
-        password of the miner using the Whatsminer tool.  New password
-        has a max length of 8 bytes, using letters, numbers, and
-        underscores.
-
-        :param old_pwd: The old admin password.
-        :param new_pwd: The new password to set.
-        :return: A reply informing of the status of setting the
-        password.
-        """
-        # check if password length is greater than 8 bytes
-        if len(new_pwd.encode("utf-8")) > 8:
-            return APIError(
-                f"New password too long, the max length is 8.  "
-                f"Password size: {len(new_pwd.encode('utf-8'))}"
-            )
-        command = {"cmd": "update_pwd", "old": old_pwd, "new": new_pwd}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def set_target_freq(self, percent: int):
-        """Update the target frequency.
-
-        Update the target frequency, only works after changing the
-        password of the miner using the Whatsminer tool. The new
-        frequency must be between -10% and 100%.
-
-        :param percent: The frequency % to set.
-        :return: A reply informing of the status of setting the
-        frequency.
-        """
-        if not -10 < percent < 100:
-            return APIError(
-                f"Frequency % is outside of the allowed "
-                f"range.  Please set a % between -10 and "
-                f"100"
-            )
-        command = {"cmd": "set_target_freq", "percent": str(percent)}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def enable_fast_boot(self):
-        """Turn on fast boot.
-
-        Turn on fast boot, only works after changing the password of
-        the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of enabling fast boot.
-        """
-        command = {"cmd": "enable_btminer_fast_boot"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def disable_fast_boot(self):
-        """Turn off fast boot.
-
-        Turn off fast boot, only works after changing the password of
-        the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of disabling fast boot.
-        """
-        command = {"cmd": "disable_btminer_fast_boot"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def enable_web_pools(self):
-        """Turn on web pool updates.
-
-        Turn on web pool updates, only works after changing the
-        password of the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of enabling web pools.
-        """
-        command = {"cmd": "enable_web_pools"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def disable_web_pools(self):
-        """Turn off web pool updates.
-
-        Turn off web pool updates, only works after changing the
-        password of the miner using the Whatsminer tool.
-
-        :return: A reply informing of the status of disabling web
-        pools.
-        """
-        command = {"cmd": "disable_web_pools"}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def set_hostname(self, hostname: str):
-        """Set the hostname of the miner.
-
-        Set the hostname of the miner, only works after changing the
-        password of the miner using the Whatsminer tool.
-
-
-        :param hostname: The new hostname to use.
-        :return: A reply informing of the status of setting the
-        hostname.
-        """
-        command = {"cmd": "set_hostname", "hostname": hostname}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def set_power_pct(self, percent: int):
-        """Set the power percentage of the miner.
-
-        Set the power percentage of the miner, only works after changing
-        the password of the miner using the Whatsminer tool.
-
-        :param percent: The power percentage to set.
-        :return: A reply informing of the status of setting the
-        power percentage.
-        """
-
-        if not 0 < percent < 100:
-            return APIError(
-                f"Power PCT % is outside of the allowed "
-                f"range.  Please set a % between 0 and "
-                f"100"
-            )
-        command = {"cmd": "set_power_pct", "percent": str(percent)}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    async def pre_power_on(self, complete: bool, msg: str):
-        """Configure or check status of pre power on.
-
-        Configure or check status of pre power on, only works after
-        changing the password of the miner using the Whatsminer tool.
-
-        :param complete: check whether pre power on is complete.
-        :param msg: the message to check.
-        "wait for adjust temp" or
-        "adjust complete" or
-        "adjust continue"
-        :return: A reply informing of the status of pre power on.
-        """
-
-        if not msg == "wait for adjust temp" or "adjust complete" or "adjust continue":
-            return APIError(
-                "Message is incorrect, please choose one of "
-                '["wait for adjust temp", '
-                '"adjust complete", '
-                '"adjust continue"]'
-            )
-        if complete:
-            complete = "true"
-        else:
-            complete = "false"
-        command = {"cmd": "pre_power_on", "complete": complete, "msg": msg}
-        token_data = await self.get_token()
-        enc_command = create_privileged_cmd(token_data, command)
-        return await self.send_command(enc_command)
-
-    #### END privileged COMMANDS ####
-
-    async def summary(self):
-        """Get the summary status from the miner.
-
-        :return: Summary status of the miner.
-        """
-        return await self.send_command("summary")
-
-    async def pools(self):
-        """Get the pool status from the miner.
-
-        :return: Pool status of the miner.
-        """
-        return await self.send_command("pools")
-
-    async def devs(self):
-        """Get data on each PGA/ASC with their details.
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        return await self.send_command("devs")
-
-    async def edevs(self):
-        """Get data on each PGA/ASC with their details, ignoring
-         blacklisted and zombie devices.
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        return await self.send_command("edevs")
-
-    async def devdetails(self):
-        """Get data on all devices with their static details.
-
-        :return: Data on all devices with their static details.
-        """
-        return await self.send_command("devdetails")
-
-    async def get_psu(self):
-        """Get data on the PSU and power information.
-
-        :return: Data on the PSU and power information.
-        """
-        return await self.send_command("get_psu")
-
-    async def version(self):
-        """Get version data for the miner.
-
-        Get version data for the miner.  This calls another function,
-        self.get_version(), but is named version to stay consistent
-        with the other miner APIs.
-
-        :return: Version data for the miner.
-        """
-        return await self.get_version()
-
-    async def get_version(self):
-        """Get version data for the miner.
-
-        :return: Version data for the miner.
-        """
-        return await self.send_command("get_version")
-
-    async def status(self):
-        """Get BTMiner status and firmware version.
-
-        :return: BTMiner status and firmware version.
-        """
-        return await self.send_command("status")
-
-    async def get_miner_info(self):
-        """Get general miner info.
-
-        :return: General miner info.
-        """
-        return await self.send_command("get_miner_info")

API/cgminer.py

@@ -1,491 +0,0 @@
-from API import BaseMinerAPI
-
-
-class CGMinerAPI(BaseMinerAPI):
-    """An abstraction of the CGMiner API.
-
-    Each method corresponds to an API command in GGMiner.
-
-    CGMiner API documentation:
-        https://github.com/ckolivas/cgminer/blob/master/API-README
-
-    This class abstracts use of the CGMiner API, as well as the
-    methods for sending commands to it.  The self.send_command()
-    function handles sending a command to the miner asynchronously, and
-    as such is the base for many of the functions in this class, which
-    rely on it to send the command for them.
-
-    :param ip: The IP of the miner to reference the API on.
-    :param port: The port to reference the API on.  Default is 4028.
-    """
-
-    def __init__(self, ip, port=4028):
-        super().__init__(ip, port)
-
-    async def version(self) -> dict:
-        """Get miner version info.
-
-        :return: Miner version information.
-        """
-        return await self.send_command("version")
-
-    async def config(self) -> dict:
-        """Get some basic configuration info.
-
-        :return: Some miner configuration information:
-            ASC Count <- the number of ASCs
-            PGA Count <- the number of PGAs
-            Pool Count <- the number of Pools
-            Strategy <- the current pool strategy
-            Log Interval <- the interval of logging
-            Device Code <- list of compiled device drivers
-            OS <- the current operating system
-        """
-        return await self.send_command("config")
-
-    async def summary(self) -> dict:
-        """Get the status summary of the miner.
-
-        :return: The status summary of the miner.
-        """
-        return await self.send_command("summary")
-
-    async def pools(self) -> dict:
-        """Get pool information.
-
-        :return: Miner pool information.
-        """
-        return await self.send_command("pools")
-
-    async def devs(self) -> dict:
-        """Get data on each PGA/ASC with their details.
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        return await self.send_command("devs")
-
-    async def edevs(self, old: bool = False) -> dict:
-        """Get data on each PGA/ASC with their details, ignoring
-         blacklisted and zombie devices.
-
-        :param old: Include zombie devices that became zombies less
-        than 'old' seconds ago
-
-        :return: Data on each PGA/ASC with their details.
-        """
-        if old:
-            return await self.send_command("edevs", parameters="old")
-        else:
-            return await self.send_command("edevs")
-
-    async def pga(self, n: int) -> dict:
-        """Get data from PGA n.
-
-        :param n: The PGA number to get data from.
-
-        :return: Data on the PGA n.
-        """
-        return await self.send_command("pga", parameters=n)
-
-    async def pgacount(self) -> dict:
-        """Get data fon all PGAs.
-
-        :return: Data on the PGAs connected.
-        """
-        return await self.send_command("pgacount")
-
-    async def switchpool(self, n: int) -> dict:
-        """Switch pools to pool n.
-
-        :param n: The pool to switch to.
-
-        :return: A confirmation of switching to pool n.
-        """
-        return await self.send_command("switchpool", parameters=n)
-
-    async def enablepool(self, n: int) -> dict:
-        """Enable pool n.
-
-        :param n: The pool to enable.
-
-        :return: A confirmation of enabling pool n.
-        """
-        return await self.send_command("enablepool", parameters=n)
-
-    async def addpool(self, url: str, username: str, password: str) -> dict:
-        """Add a pool to the miner.
-
-        :param url: The URL of the new pool to add.
-        :param username: The users username on the new pool.
-        :param password: The worker password on the new pool.
-
-        :return: A confirmation of adding the pool.
-        """
-        return await self.send_command(
-            "addpool", parameters=f"{url}, " f"{username}, " f"{password}"
-        )
-
-    async def poolpriority(self, *n: int) -> dict:
-        """Set pool priority.
-
-        :param n: Pools in order of priority.
-
-        :return: A confirmation of setting pool priority.
-        """
-        pools = f"{','.join([str(item) for item in n])}"
-        return await self.send_command("poolpriority", parameters=pools)
-
-    async def poolquota(self, n: int, q: int) -> dict:
-        """Set pool quota.
-
-        :param n: Pool number to set quota on.
-        :param q: Quota to set the pool to.
-
-        :return: A confirmation of setting pool quota.
-        """
-        return await self.send_command("poolquota", parameters=f"{n}, " f"{q}")
-
-    async def disablepool(self, n: int) -> dict:
-        """Disable a pool.
-
-        :param n: Pool to disable.
-
-        :return: A confirmation of diabling the pool.
-        """
-        return await self.send_command("disablepool", parameters=n)
-
-    async def removepool(self, n: int) -> dict:
-        """Remove a pool.
-
-        :param n: Pool to remove.
-
-        :return: A confirmation of removing the pool.
-        """
-        return await self.send_command("removepool", parameters=n)
-
-    async def save(self, filename: str = None) -> dict:
-        """Save the config.
-
-        :param filename: Filename to save the config as.
-
-        :return: A confirmation of saving the config.
-        """
-        if filename:
-            return await self.send_command("save", parameters=filename)
-        else:
-            return await self.send_command("save")
-
-    async def quit(self) -> dict:
-        """Quit CGMiner.
-
-        :return: A single "BYE" before CGMiner quits.
-        """
-        return await self.send_command("quit")
-
-    async def notify(self) -> dict:
-        """Notify the user of past errors.
-
-        :return: The last status and count of each devices problem(s).
-        """
-        return await self.send_command("notify")
-
-    async def privileged(self) -> dict:
-        """Check if you have privileged access.
-
-        :return: The STATUS section with an error if you have no
-        privileged access, or success if you have privileged access.
-        """
-        return await self.send_command("privileged")
-
-    async def pgaenable(self, n: int) -> dict:
-        """Enable PGA n.
-
-        :param n: The PGA to enable.
-
-        :return: A confirmation of enabling PGA n.
-        """
-        return await self.send_command("pgaenable", parameters=n)
-
-    async def pgadisable(self, n: int) -> dict:
-        """Disable PGA n.
-
-        :param n: The PGA to disable.
-
-        :return: A confirmation of disabling PGA n.
-        """
-        return await self.send_command("pgadisable", parameters=n)
-
-    async def pgaidentify(self, n: int) -> dict:
-        """Identify PGA n.
-
-        :param n: The PGA to identify.
-
-        :return: A confirmation of identifying PGA n.
-        """
-        return await self.send_command("pgaidentify", parameters=n)
-
-    async def devdetails(self) -> dict:
-        """Get data on all devices with their static details.
-
-        :return: Data on all devices with their static details.
-        """
-        return await self.send_command("devdetails")
-
-    async def restart(self) -> dict:
-        """Restart CGMiner using the API.
-
-        :return: A reply informing of the restart.
-        """
-        return await self.send_command("restart")
-
-    async def stats(self) -> dict:
-        """Get stats of each device/pool with more than 1 getwork.
-
-        :return: Stats of each device/pool with more than 1 getwork.
-        """
-        return await self.send_command("stats")
-
-    async def estats(self, old: bool = False) -> dict:
-        """Get stats of each device/pool with more than 1 getwork,
-        ignoring zombie devices.
-
-        :param old: Include zombie devices that became zombies less
-        than 'old' seconds ago.
-
-        :return: Stats of each device/pool with more than 1 getwork,
-        ignoring zombie devices.
-        """
-        if old:
-            return await self.send_command("estats", parameters=old)
-        else:
-            return await self.send_command("estats")
-
-    async def check(self, command: str) -> dict:
-        """Check if the command command exists in CGMiner.
-
-        :param command: The command to check.
-
-        :return: Information about a command:
-            Exists (Y/N) <- the command exists in this version
-            Access (Y/N) <- you have access to use the command
-        """
-        return await self.send_command("check", parameters=command)
-
-    async def failover_only(self, failover: bool) -> dict:
-        """Set failover-only.
-
-
-        :param failover: What to set failover-only to.
-
-        :return: Confirmation of setting failover-only.
-        """
-        return await self.send_command("failover-only", parameters=failover)
-
-    async def coin(self) -> dict:
-        """Get information on the current coin.
-
-        :return: Information about the current coin being mined:
-            Hash Method <- the hashing algorithm
-            Current Block Time <- blocktime as a float, 0 means none
-            Current Block Hash <- the hash of the current block, blank
-            means none
-            LP <- whether LP is in use on at least 1 pool
-            Network Difficulty: the current network difficulty
-        """
-        return await self.send_command("coin")
-
-    async def debug(self, setting: str) -> dict:
-        """Set a debug setting.
-
-        :param setting: Which setting to switch to. Options are:
-                Silent,
-                Quiet,
-                Verbose,
-                Debug,
-                RPCProto,
-                PerDevice,
-                WorkTime,
-                Normal.
-
-        :return: Data on which debug setting was enabled or disabled.
-        """
-        return await self.send_command("debug", parameters=setting)
-
-    async def setconfig(self, name: str, n: int) -> dict:
-        """Set config of name to value n.
-
-        :param name: The name of the config setting to set. Options are:
-                queue,
-                scantime,
-                expiry.
-        :param n: The value to set the 'name' setting to.
-
-        :return: The results of setting config of name to n.
-        """
-        return await self.send_command("setconfig", parameters=f"{name}, " f"{n}")
-
-    async def usbstats(self) -> dict:
-        """Get stats of all USB devices except ztex.
-
-        :return: The stats of all USB devices except ztex.
-        """
-        return await self.send_command("usbstats")
-
-    async def pgaset(self, n: int, opt: str, val: int = None) -> dict:
-        """Set PGA option opt to val on PGA n.
-
-        Options:
-            MMQ -
-                opt: clock
-                val: 160 - 230 (multiple of 2)
-            CMR -
-                opt: clock
-                val: 100 - 220
-
-        :param n: The PGA to set the options on.
-        :param opt: The option to set. Setting this to 'help'
-        returns a help message.
-        :param val: The value to set the option to.
-
-        :return: Confirmation of setting PGA n with opt[,val].
-        """
-        if val:
-            return await self.send_command(
-                "pgaset", parameters=f"{n}, " f"{opt}, " f"{val}"
-            )
-        else:
-            return await self.send_command("pgaset", parameters=f"{n}, " f"{opt}")
-
-    async def zero(self, which: str, summary: bool) -> dict:
-        """Zero a device.
-
-        :param which: Which device to zero.
-            Setting this to 'all' zeros all devices.
-            Setting this to 'bestshare' zeros only the bestshare  values
-            for each pool and global.
-        :param summary: Whether or not to show a full summary.
-
-
-        :return: the STATUS section with info on the zero and optional
-        summary.
-        """
-        return await self.send_command("zero", parameters=f"{which}, " f"{summary}")
-
-    async def hotplug(self, n: int) -> dict:
-        """Enable hotplug.
-
-        :param n: The device number to set hotplug on.
-
-        :return: Information on hotplug status.
-        """
-        return await self.send_command("hotplug", parameters=n)
-
-    async def asc(self, n: int) -> dict:
-        """Get data for ASC device n.
-
-        :param n: The device to get data for.
-
-        :return: The data for ASC device n.
-        """
-        return await self.send_command("asc", parameters=n)
-
-    async def ascenable(self, n: int) -> dict:
-        """Enable ASC device n.
-
-        :param n: The device to enable.
-
-        :return: Confirmation of enabling ASC device n.
-        """
-        return await self.send_command("ascenable", parameters=n)
-
-    async def ascdisable(self, n: int) -> dict:
-        """Disable ASC device n.
-
-        :param n: The device to disable.
-
-        :return: Confirmation of disabling ASC device n.
-        """
-        return await self.send_command("ascdisable", parameters=n)
-
-    async def ascidentify(self, n: int) -> dict:
-        """Identify ASC device n.
-
-        :param n: The device to identify.
-
-        :return: Confirmation of identifying ASC device n.
-        """
-        return await self.send_command("ascidentify", parameters=n)
-
-    async def asccount(self) -> dict:
-        """Get data on the number of ASC devices and their info.
-
-        :return: Data on all ASC devices.
-        """
-        return await self.send_command("asccount")
-
-    async def ascset(self, n: int, opt: str, val: int = None) -> dict:
-        """Set ASC n option opt to value val.
-
-        Sets an option on the ASC n to a value.  Allowed options are:
-            AVA+BTB -
-                opt: freq
-                val: 256 - 1024 (chip frequency)
-            BTB -
-                opt: millivolts
-                val: 1000 - 1400 (core voltage)
-            MBA -
-                opt: reset
-                val: 0 - # of chips (reset a chip)
-
-                opt: freq
-                val: 0 - # of chips, 100 - 1400 (chip frequency)
-
-                opt: ledcount
-                val: 0 - 100 (chip count for LED)
-
-                opt: ledlimit
-                val: 0 - 200 (LED off below GH/s)
-
-                opt: spidelay
-                val: 0 - 9999 (SPI per I/O delay)
-
-                opt: spireset
-                val: i or s, 0 - 9999 (SPI regular reset)
-
-                opt: spisleep
-                val: 0 - 9999 (SPI reset sleep in ms)
-            BMA -
-                opt: volt
-                val: 0 - 9
-
-                opt: clock
-                val: 0 - 15
-
-
-        :param n: The ASC to set the options on.
-        :param opt: The option to set. Setting this to 'help' returns a
-        help message.
-        :param val: The value to set the option to.
-
-        :return: Confirmation of setting option opt to value val.
-        """
-        if val:
-            return await self.send_command(
-                "ascset", parameters=f"{n}, " f"{opt}, " f"{val}"
-            )
-        else:
-            return await self.send_command("ascset", parameters=f"{n}, " f"{opt}")
-
-    async def lcd(self) -> dict:
-        """Get a general all-in-one status summary of the miner.
-
-        :return: An all-in-one status summary of the miner.
-        """
-        return await self.send_command("lcd")
-
-    async def lockstats(self) -> dict:
-        """Write lockstats to STDERR.
-
-        :return: The result of writing the lock stats to STDERR.
-        """
-        return await self.send_command("lockstats")

API/unknown.py

@@ -1,80 +0,0 @@
-from API import BaseMinerAPI
-
-
-class UnknownAPI(BaseMinerAPI):
-    """An abstraction of an API for a miner which is unknown.
-
-    This class is designed to try to be a intersection of as many miner APIs
-    and API commands as possible (API ⋂ API), to ensure that it can be used
-    with as many APIs as possible.
-    """
-
-    def __init__(self, ip, port=4028):
-        super().__init__(ip, port)
-
-    async def asccount(self) -> dict:
-        return await self.send_command("asccount")
-
-    async def asc(self, n: int) -> dict:
-        return await self.send_command("asc", parameters=n)
-
-    async def devdetails(self) -> dict:
-        return await self.send_command("devdetails")
-
-    async def devs(self) -> dict:
-        return await self.send_command("devs")
-
-    async def edevs(self, old: bool = False) -> dict:
-        if old:
-            return await self.send_command("edevs", parameters="old")
-        else:
-            return await self.send_command("edevs")
-
-    async def pools(self) -> dict:
-        return await self.send_command("pools")
-
-    async def summary(self) -> dict:
-        return await self.send_command("summary")
-
-    async def stats(self) -> dict:
-        return await self.send_command("stats")
-
-    async def version(self) -> dict:
-        return await self.send_command("version")
-
-    async def estats(self) -> dict:
-        return await self.send_command("estats")
-
-    async def check(self) -> dict:
-        return await self.send_command("check")
-
-    async def coin(self) -> dict:
-        return await self.send_command("coin")
-
-    async def lcd(self) -> dict:
-        return await self.send_command("lcd")
-
-    async def switchpool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("switchpool", parameters=n)
-
-    async def enablepool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("enablepool", parameters=n)
-
-    async def disablepool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("disablepool", parameters=n)
-
-    async def addpool(self, url: str, username: str, password: str) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("addpool", parameters=f"{url}, {username}, {password}")
-
-    async def removepool(self, n: int) -> dict:
-        # BOS has not implemented this yet, they will in the future
-        raise NotImplementedError
-        # return await self.send_command("removepool", parameters=n)

Dockerfile

@@ -1,13 +0,0 @@
-FROM python:3.10-slim-buster
-
-EXPOSE 80
-
-WORKDIR /minerInterface-web_monitor
-
-COPY tools/web_monitor/requirements.txt .
-
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
-
-COPY . .
-
-CMD ["uvicorn", "tools.web_monitor.app:app", "--host", "0.0.0.0", "--port", "80"]

LICENSE.txt

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

README.md

@@ -1,300 +1,286 @@
-# minerInterface
-*A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH.*
-## Usage
-To use this repo, first download it, create a virtual environment, enter the virtual environment, and install relevant packages by navigating to this directory and running ```pip install -r requirements.txt``` on Windows or ```pip3 install -r requirements.txt``` on Mac or UNIX if the first command fails.
+# pyasic
+*A simplified and standardized interface for Bitcoin ASICs.*
 
-For those of you who aren't comfortable with code and developer tools, there are windows builds of the GUI applications here -> (https://drive.google.com/drive/folders/1DjR8UOS_g0ehfiJcgmrV0FFoqFvE9akW?usp=sharing)
+[![PyPI - Version](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/pyasic)](https://pypi.org/project/pyasic/)
 
-### CFG Util
-*CFG Util is a GUI for interfacing with the miners easily, it is mostly self-explanatory.*
+[![Python - Supported Versions](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![CodeFactor - Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)](https://www.codefactor.io/repository/github/upstreamdata/pyasic)
+[![Commit Activity - master](https://img.shields.io/github/commit-activity/y/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/commits/master/)
 
-To use CFG Util you have 2 options -
-1. Run it directly with the file ```config_tool.py``` or import it with ```from cfg_util import main```, then run the ```main()``` function in an asyncio event loop like -
+[![Code Style - Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Read The Docs - Docs](https://img.shields.io/readthedocs/pyasic)](https://docs.pyasic.org)
+[![License - Apache 2.0](https://img.shields.io/github/license/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/blob/master/LICENSE.txt)
 
-```python
-from tools.cfg_util import main
+---
+## 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](https://docs.pyasic.org/en/latest/miners/supported_types/)
+
+---
+## 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
 
-if __name__ == '__main__':
-    main()
 ```
-2. Make a build of the CFG Util for your system using cx_freeze and ```make_cfg_tool_exe.py```
-(Alternatively, you can get a build made by me here -> https://drive.google.com/drive/folders/1nzojuGRu0IszIGpwx7SvG5RlJ2_KXIOv)
-   1. Open either Command Prompt on Windows or Terminal on Mac or UNIX.
-   2. Navigate to this directory, and run ```make_cfg_tool_exe.py build``` on Windows or ```python3 make_cfg_tool_exe.py``` on Mac or UNIX.
-
-### Interfacing with miners programmatically
-<br>
-
-##### Note: If you are trying to interface with Whatsminers, there is a bug in the way they are interacted with on Windows, so to fix that you need to change the event loop policy using this code: 
-```python
-# need to import these 2 libraries, you need asyncio anyway so make sure you have sys imported
-import sys
-import asyncio
-
-# if the computer is windows, set the event loop policy to a WindowsSelector policy
-if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
-    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+    poetry install
 ```
 
-##### It is likely a good idea to use this code in your program anyway to be preventative.
-<br>
+  - [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
 
-To write your own custom programs with this repo, you have many options.
+```
+    pyenv install <python version number>
+    pyenv virtualenv <python version number> <env name>
+    pyenv activate <env name>
+```
 
-It is recommended that you explore the files in this repo to familiarize yourself with them, try starting with the miners module and going from there.
+  - [conda](https://docs.conda.io/en/latest/)
 
-A basic script to find all miners on the network and get the hashrate from them looks like this -
+##### Installing `pyasic`
 
+`python -m pip install pyasic` or `poetry install`
+
+##### Additional Developer Setup
+```
+poetry install --with dev
+pre-commit install
+```
+
+---
+## 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
+To scan for miners in `pyasic`, we use the class `MinerNetwork`, which abstracts the search, communication, identification, setup, and return of a miner to 1 command.
+The command `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
+
+
+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
+
+    # scan for miners asynchronously
+    # this will return the correct type of miners if they are supported with all functionality.
+    miners = await network.scan()
+    print(miners)
+
+if __name__ == "__main__":
+    asyncio.run(scan_miners())  # run the scan asynchronously with asyncio.run()
+```
+
+---
+##### Creating miners based on IP
+If you already know the IP address of your miner or miners, you can use the `MinerFactory` to communicate and identify the miners, or an abstraction of its functionality, `get_miner()`.
+The function `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
+
+
+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")
+    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)
+    print(miners)
+
+
+if __name__ == "__main__":
+    asyncio.run(get_miners())  # 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` with all data it can gather from the miner.
+Each piece of data in a `MinerData` instance can be referenced by getting it as an attribute, such as `MinerData().hashrate`.
+
+##### One miner
 ```python
 import asyncio
-from network import MinerNetwork
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from pyasic import get_miner
 
+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
+        print(miner_data.hashrate)  # hashrate of the miner in TH/s
 
-async def get_hashrate():
-    # Miner Network class allows for easy scanning of a network
-    # Give it any IP on a network and it will find the whole subnet
-    # It can also be passed a subnet mask:
-    # miner_network = MinerNetwork('192.168.1.55', mask=23)
-    miner_network = MinerNetwork('192.168.1.1')
-    # Miner Network scan function returns Miner classes for all miners found
-    miners = await miner_network.scan_network_for_miners()
-    # Each miner will return with its own set of functions, and an API class instance
-    tasks = [miner.api.summary() for miner in miners]
-    # Gather all tasks asynchronously and run them
-    data = await asyncio.gather(*tasks)
-    parse_tasks = []
-    for item in data:
-        # safe_parse_api_data parses the data from a miner API
-        # It will raise an APIError (from API import APIError) if there is a problem
-        parse_tasks.append(safe_parse_api_data(item, 'SUMMARY', 0, 'MHS 5s'))
-    # Gather all tasks asynchronously and run them
-    data = await asyncio.gather(*parse_tasks)
-    # Print a list of all the hashrates
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_hashrate())
+if __name__ == "__main__":
+    asyncio.run(gather_miner_data())
 ```
-<br>
-You can also create your own miner without scanning if you know the IP:
+---
+##### 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
 
+
+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()
+
+    # 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
+
+if __name__ == "__main__":
+    asyncio.run(gather_miner_data())
+```
+
+---
+## 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 `BaseMiner`.
+
+These functions are
+`check_light`,
+`fault_light_off`,
+`fault_light_on`,
+`get_config`,
+`get_data`,
+`get_errors`,
+`get_hostname`,
+`get_model`,
+`reboot`,
+`restart_backend`,
+`stop_mining`,
+`resume_mining`,
+`is_mining`,
+`send_config`, and
+`set_power_limit`.
+
+##### Usage
 ```python
 import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from pyasic import get_miner
 
 
-async def get_miner_hashrate(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    summary = await miner.api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, 'MHS 5s')
-    print(data)
+async def set_fault_light():
+    miner = await get_miner("192.168.1.20")
 
+    # call control function
+    await miner.fault_light_on()
 
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_hashrate(str("192.168.1.69")))
+if __name__ == "__main__":
+    asyncio.run(set_fault_light())
 ```
 
-<br>
-Or generate a miner directly without the factory:
+---
+## Helper dataclasses
 
+##### `MinerConfig` and `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
+
+`MinerData` is a return from the [`get_data()`](#get-data) function, and is used to have a consistent dataset across all returns.
+
+You can call `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.
+
+`MinerData` instances can also be added to each other to combine their data and can be divided by a number to divide all their data, allowing you to get average data from many miners by doing -
+```python
+from pyasic import MinerData
+
+# examples of miner data
+d1 = MinerData("192.168.1.1")
+d2 = MinerData("192.168.1.2")
+
+list_of_miner_data = [d1, d2]
+
+average_data = sum(list_of_miner_data, start=MinerData("0.0.0.0"))/len(list_of_miner_data)
+```
+
+---
+
+##### MinerConfig
+
+`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).
+
+Each miner has a unique way to convert the `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` and will do the conversion to the right type for you.
+
+You can use the `MinerConfig` as follows:
 ```python
 import asyncio
-from miners.bosminer import BOSMiner
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from pyasic import get_miner
 
 
-async def get_miner_hashrate(ip: str):
-    # Create a BOSminer miner object
-    miner = BOSMiner(ip)
-    # Get the API data
-    summary = await miner.api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, 'MHS 5s')
-    print(data)
+async def set_fault_light():
+    miner = await get_miner("192.168.1.20")
 
+    # get config
+    cfg = await miner.get_config()
+
+    # send config
+    await miner.send_config(cfg)
+
+if __name__ == "__main__":
+    asyncio.run(set_fault_light())
 
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_hashrate(str("192.168.1.69")))
 ```
 
-<br>
-Or finally, just get the API directly:
+---
+## 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:
 
 ```python
-import asyncio
-from API.bosminer import BOSMinerAPI
-from tools.cfg_util.func.parse_data import safe_parse_api_data
+from pyasic import settings
 
-
-async def get_miner_hashrate(ip: str):
-    # Create a BOSminerAPI object
-    # Port can be declared manually, if not it defaults to 4028
-    api = BOSMinerAPI(ip, port=4028)
-    # Get the API data
-    summary = await api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, 'MHS 5s')
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_hashrate(str("192.168.1.69")))
+settings.update("default_antminer_web_password", "my_pwd")
 ```
 
-
-Now that you know that, lets move on to some common API functions that you might want to use.
-
-### Common commands:
-* Getting pool data:
-
-```python
-import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_pool_data(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    pools = await miner.api.pools()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(pools, 'POOLS')
-    # parse further from here to get all the pool info you want.
-    # each pool is on a different index eg:
-    # data[0] is pool 1
-    # data[1] is pool 2
-    # etc
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_pool_data(str("192.168.1.69")))
+##### Default values:
 ```
+"network_ping_retries": 1,
+"network_ping_timeout": 3,
+"network_scan_semaphore": None,
+"factory_get_retries": 1,
+"factory_get_timeout": 3,
+"get_data_retries": 1,
+"api_function_timeout": 5,
+"antminer_mining_mode_as_str": False,
+"default_whatsminer_rpc_password": "admin",
+"default_innosilicon_web_password": "admin",
+"default_antminer_web_password": "root",
+"default_bosminer_web_password": "root",
+"default_vnish_web_password": "admin",
+"default_goldshell_web_password": "123456789",
+"default_auradine_web_password": "admin",
+"default_epic_web_password": "letmein",
+"default_hive_web_password": "admin",
+"default_antminer_ssh_password": "miner",
+"default_bosminer_ssh_password": "root",
 
-* Getting temperature data:
-
-This one is a bit tougher, lots of miners do this a different way, you might need to experiment a bit to find what works for you.
-BraiinsOS uses the "temps" command, Whatsminers has it in "devs", Avalonminers put it in "stats" as well as some other miners,
-but the spot I like to try first is in "summary".
-
-A pretty good example of really trying to make this robust is in ```cfg_util.func.miners``` in the ```get_formatted_data()``` function.
-
-```python
-import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_temperature_data(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    summary = await miner.api.summary()
-    # safe_parse_api_data parses the data from a miner API
-    # It will raise an APIError (from API import APIError) if there is a problem
-    data = await safe_parse_api_data(summary, 'SUMMARY', 0, "Temperature")
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_temperature_data(str("192.168.1.69")))
+# ADVANCED
+# Only use this if you know what you are doing
+"socket_linger_time": 1000,
 ```
-
-* Getting power data:
-
-How about data on the power usage of the miner?  This one only works for Whatsminers and BraiinsOS for now, and the Braiins one just uses the tuning setting, but its good enough for basic uses.
-
-```python
-import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_power_data(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # check if this can be sent the "tunerstatus" command, BraiinsOS only
-    if "tunerstatus" in miner.api.get_commands():
-        # send the command
-        tunerstatus = await miner.api.tunerstatus()
-        # parse the return
-        data = await safe_parse_api_data(tunerstatus, 'TUNERSTATUS', 0, "PowerLimit")
-    else:
-        # send the command
-        # whatsminers have the power info in summary
-        summary = await miner.api.summary()
-        # parse the return
-        data = await safe_parse_api_data(summary, 'SUMMARY', 0, "Power")
-
-    print(data)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_power_data(str("192.168.1.69")))
-```
-
-* Multicommands:
-
-Multicommands make it much easier to get many types of data all at once.  The multicommand function will also remove any commands that your API can't handle automatically.
-How about we get the current pool user and hashrate in 1 command?
-
-```python
-import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
-from tools.cfg_util.func.parse_data import safe_parse_api_data
-
-
-async def get_miner_hashrate_and_pool(ip: str):
-    # Instantiate a Miner Factory to generate miners from their IP
-    miner_factory = MinerFactory()
-    # Make the string IP into an IP address
-    miner_ip = ipaddress.ip_address(ip)
-    # Wait for the factory to return the miner
-    miner = await miner_factory.get_miner(miner_ip)
-    # Get the API data
-    api_data = await miner.api.multicommand("pools", "summary")
-    if "pools" in api_data.keys():
-        user = await safe_parse_api_data(api_data, "pools", 0, "POOLS", 0, "User")
-        print(user)
-    if "summary" in api_data.keys():
-        hashrate = await safe_parse_api_data(api_data, "summary", 0, "SUMMARY", 0, "MHS av")
-        print(hashrate)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_miner_hashrate_and_pool(str("192.168.1.9")))
-```
-
-

board_util.py

@@ -1,4 +0,0 @@
-from tools.bad_board_util import main
-
-if __name__ == "__main__":
-    main()

config/__init__.py

@@ -1,78 +0,0 @@
-"""
-SAMPLE CONFIG
--------------------
-{
-    "format": {
-        "version": "1.2+", # -> (default = "1.2+", str, (bos: format.version))
-        "model": "Antminer S9", # -> (default = "Antminer S9", str, (bos: format.model))
-        "generator": "upstream_config_util", # -> (hidden, always = "upstream_config_util", str, (bos: format.generator))
-        "timestamp": 1606842000, # -> (hidden, always = int(time.time()) (current unix time), int, (bos: format.timestamp))
-    },
-    "temperature": {
-        "mode": "auto", # -> (default = "auto", str["auto", "manual", "disabled"], (bos: temp_control.mode))
-        "target": 70.0, # -> (default = 70.0, float, (bos: temp_control.target_temp))
-        "hot": 80.0, # -> (default = 80.0, float, (bos: temp_control.hot_temp))
-        "danger": 90.0, # -> (default = 90.0, float, (bos: temp_control.dangerous_temp))
-    },
-    "fans": { # -> (optional, required if temperature["mode"] == "disabled", (bos: fan_control))
-        "min_fans": 1, # -> (default = 1, int, (bos: fan_control.min_fans))
-        "speed": 100, # -> (default = 100, 0 < int < 100, (bos: fan_control.speed))
-    },
-    "asicboost": True, # -> (default = True, bool, (bos : hash_chain_global.asic_boost))
-    "pool_groups": [
-        {
-            "group_name": "Upstream", # -> (default = "group_{index}" (group_0), str, (bos: group.[index].name))
-            "quota": 1, # -> (default = 1, int, (bos: group.[index].quota))
-            "pools": [
-                {
-                    "url": "stratum+tcp://stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataInc.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://us-east.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataInc.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://ca.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataInc.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-            ]
-        },
-        {
-            "group_name": "Upstream2", # -> (default = "group_{index}" (group_1), str, (bos: group.[index].name))
-            "quota": 4, # -> (default = 1, int, (bos: group.[index].quota))
-            "pools": [
-                {
-                    "url": "stratum+tcp://stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataTesting.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://us-east.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataTesting.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-                {
-                    "url": "stratum+tcp://ca.stratum.slushpool.com:3333", # -> (str, (bos: group.[index].pool.[index].url))
-                    "username": "UpstreamDataTesting.test", # -> (str, (bos: group.[index].pool.[index].user))
-                    "password": "123", # -> (str, (bos: group.[index].pool.[index].password))
-                },
-            ]
-        },
-    ],
-    "autotuning": {
-        "enabled": True, # -> (default = True, bool), (bos: autotuning.enabled)
-        "wattage": 900, # -> (default = 900, int, (bos: autotuning.psu_power_limit))
-    },
-    "power_scaling": {
-        "enabled": False, # -> (default = False, bool, (bos: power_scaling.enabled))
-        "power_step": 100, # -> (default = 100, int, (bos: power_scaling.power_step))
-        "min_psu_power_limit": 800, # -> (default = 800, int, (bos: power_scaling.min_psu_power_limit))
-        "shutdown_enabled": True, # -> (default = False, bool, (bos: power_scaling.shutdown_enabled))
-        "shutdown_duration": 3.0, # -> (default = 3.0, float, (bos: power_scaling.shutdown_duration))
-    }
-}
-"""

config/bos.py

@@ -1,221 +0,0 @@
-import time
-import yaml
-import toml
-
-
-async def bos_config_convert(config: dict):
-    out_config = {}
-    for opt in config:
-        if opt == "format":
-            out_config["format"] = config[opt]
-            out_config["format"]["generator"] = "upstream_config_util"
-            out_config["format"]["timestamp"] = int(time.time())
-        elif opt == "temp_control":
-            out_config["temperature"] = {}
-            if "mode" in config[opt].keys():
-                out_config["temperature"]["mode"] = config[opt]["mode"]
-            else:
-                out_config["temperature"]["mode"] = "auto"
-
-            if "target_temp" in config[opt].keys():
-                out_config["temperature"]["target"] = config[opt]["target_temp"]
-            else:
-                out_config["temperature"]["target"] = 70.0
-
-            if "hot_temp" in config[opt].keys():
-                out_config["temperature"]["hot"] = config[opt]["hot_temp"]
-            else:
-                out_config["temperature"]["hot"] = 80.0
-
-            if "dangerous_temp" in config[opt].keys():
-                out_config["temperature"]["danger"] = config[opt]["dangerous_temp"]
-            else:
-                out_config["temperature"]["danger"] = 90.0
-        elif opt == "fan_control":
-            out_config["fans"] = {}
-            if "min_fans" in config[opt].keys():
-                out_config["fans"]["min_fans"] = config[opt]["min_fans"]
-            else:
-                out_config["fans"]["min_fans"] = 1
-            if "speed" in config[opt].keys():
-                out_config["fans"]["speed"] = config[opt]["speed"]
-            else:
-                out_config["fans"]["speed"] = 100
-        elif opt == "group":
-            out_config["pool_groups"] = [{} for _item in range(len(config[opt]))]
-            for idx in range(len(config[opt])):
-                out_config["pool_groups"][idx]["pools"] = []
-                out_config["pool_groups"][idx] = {}
-                if "name" in config[opt][idx].keys():
-                    out_config["pool_groups"][idx]["group_name"] = config[opt][idx][
-                        "name"
-                    ]
-                else:
-                    out_config["pool_groups"][idx]["group_name"] = f"group_{idx}"
-                if "quota" in config[opt][idx].keys():
-                    out_config["pool_groups"][idx]["quota"] = config[opt][idx]["quota"]
-                else:
-                    out_config["pool_groups"][idx]["quota"] = 1
-                out_config["pool_groups"][idx]["pools"] = [
-                    {} for _item in range(len(config[opt][idx]["pool"]))
-                ]
-                for pool_idx in range(len(config[opt][idx]["pool"])):
-                    out_config["pool_groups"][idx]["pools"][pool_idx]["url"] = config[
-                        opt
-                    ][idx]["pool"][pool_idx]["url"]
-                    out_config["pool_groups"][idx]["pools"][pool_idx][
-                        "username"
-                    ] = config[opt][idx]["pool"][pool_idx]["user"]
-                    out_config["pool_groups"][idx]["pools"][pool_idx][
-                        "password"
-                    ] = config[opt][idx]["pool"][pool_idx]["password"]
-        elif opt == "autotuning":
-            out_config["autotuning"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["autotuning"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["autotuning"]["enabled"] = True
-            if "psu_power_limit" in config[opt].keys():
-                out_config["autotuning"]["wattage"] = config[opt]["psu_power_limit"]
-            else:
-                out_config["autotuning"]["wattage"] = 900
-        elif opt == "power_scaling":
-            out_config["power_scaling"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["power_scaling"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["power_scaling"]["enabled"] = False
-            if "power_step" in config[opt].keys():
-                out_config["power_scaling"]["power_step"] = config[opt]["power_step"]
-            else:
-                out_config["power_scaling"]["power_step"] = 100
-            if "min_psu_power_limit" in config[opt].keys():
-                out_config["power_scaling"]["min_psu_power_limit"] = config[opt][
-                    "min_psu_power_limit"
-                ]
-            else:
-                out_config["power_scaling"]["min_psu_power_limit"] = 800
-            if "shutdown_enabled" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_enabled"] = config[opt][
-                    "shutdown_enabled"
-                ]
-            else:
-                out_config["power_scaling"]["shutdown_enabled"] = False
-            if "shutdown_duration" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_duration"] = config[opt][
-                    "shutdown_duration"
-                ]
-            else:
-                out_config["power_scaling"]["shutdown_duration"] = 3.0
-    return yaml.dump(out_config, sort_keys=False)
-
-
-async def general_config_convert_bos(yaml_config, user_suffix: str = None):
-    config = yaml.load(yaml_config, Loader=yaml.SafeLoader)
-    out_config = {}
-    for opt in config:
-        if opt == "format":
-            out_config["format"] = config[opt]
-            out_config["format"]["generator"] = "upstream_config_util"
-            out_config["format"]["timestamp"] = int(time.time())
-        elif opt == "temperature":
-            out_config["temp_control"] = {}
-            if "mode" in config[opt].keys():
-                out_config["temp_control"]["mode"] = config[opt]["mode"]
-            else:
-                out_config["temp_control"]["mode"] = "auto"
-
-            if "target" in config[opt].keys():
-                out_config["temp_control"]["target_temp"] = config[opt]["target"]
-            else:
-                out_config["temp_control"]["target_temp"] = 70.0
-
-            if "hot" in config[opt].keys():
-                out_config["temp_control"]["hot_temp"] = config[opt]["hot"]
-            else:
-                out_config["temp_control"]["hot_temp"] = 80.0
-
-            if "danger" in config[opt].keys():
-                out_config["temp_control"]["dangerous_temp"] = config[opt]["danger"]
-            else:
-                out_config["temp_control"]["dangerous_temp"] = 90.0
-        elif opt == "fans":
-            out_config["fan_control"] = {}
-            if "min_fans" in config[opt].keys():
-                out_config["fan_control"]["min_fans"] = config[opt]["min_fans"]
-            else:
-                out_config["fan_control"]["min_fans"] = 1
-            if "speed" in config[opt].keys():
-                out_config["fan_control"]["speed"] = config[opt]["speed"]
-            else:
-                out_config["fan_control"]["speed"] = 100
-        elif opt == "pool_groups":
-            out_config["group"] = [{} for _item in range(len(config[opt]))]
-            for idx in range(len(config[opt])):
-                out_config["group"][idx]["pools"] = []
-                out_config["group"][idx] = {}
-                if "group_name" in config[opt][idx].keys():
-                    out_config["group"][idx]["name"] = config[opt][idx]["group_name"]
-                else:
-                    out_config["group"][idx]["name"] = f"group_{idx}"
-                if "quota" in config[opt][idx].keys():
-                    out_config["group"][idx]["quota"] = config[opt][idx]["quota"]
-                else:
-                    out_config["group"][idx]["quota"] = 1
-                out_config["group"][idx]["pool"] = [
-                    {} for _item in range(len(config[opt][idx]["pools"]))
-                ]
-                for pool_idx in range(len(config[opt][idx]["pools"])):
-                    out_config["group"][idx]["pool"][pool_idx]["url"] = config[opt][
-                        idx
-                    ]["pools"][pool_idx]["url"]
-                    username = config[opt][idx]["pools"][pool_idx]["username"]
-                    if user_suffix:
-                        if "." in username:
-                            username = f"{username}x{user_suffix}"
-                        else:
-                            username = f"{username}.{user_suffix}"
-                    out_config["group"][idx]["pool"][pool_idx]["user"] = username
-
-                    out_config["group"][idx]["pool"][pool_idx]["password"] = config[
-                        opt
-                    ][idx]["pools"][pool_idx]["password"]
-        elif opt == "autotuning":
-            out_config["autotuning"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["autotuning"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["autotuning"]["enabled"] = True
-            if "wattage" in config[opt].keys():
-                out_config["autotuning"]["psu_power_limit"] = config[opt]["wattage"]
-            else:
-                out_config["autotuning"]["psu_power_limit"] = 900
-        elif opt == "power_scaling":
-            out_config["power_scaling"] = {}
-            if "enabled" in config[opt].keys():
-                out_config["power_scaling"]["enabled"] = config[opt]["enabled"]
-            else:
-                out_config["power_scaling"]["enabled"] = False
-            if "power_step" in config[opt].keys():
-                out_config["power_scaling"]["power_step"] = config[opt]["power_step"]
-            else:
-                out_config["power_scaling"]["power_step"] = 100
-            if "min_psu_power_limit" in config[opt].keys():
-                out_config["power_scaling"]["min_psu_power_limit"] = config[opt][
-                    "min_psu_power_limit"
-                ]
-            else:
-                out_config["power_scaling"]["min_psu_power_limit"] = 800
-            if "shutdown_enabled" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_enabled"] = config[opt][
-                    "shutdown_enabled"
-                ]
-            else:
-                out_config["power_scaling"]["shutdown_enabled"] = False
-            if "shutdown_duration" in config[opt].keys():
-                out_config["power_scaling"]["shutdown_duration"] = config[opt][
-                    "shutdown_duration"
-                ]
-            else:
-                out_config["power_scaling"]["shutdown_duration"] = 3.0
-    return out_config

config/sample_config_cgminer

@@ -1,17 +0,0 @@
-
-config cgminer 'default'
-	option pool1pw 'x'
-	option pool2pw 'x'
-	option pool3pw 'x'
-	option voltage_level_offset '0'
-	option fan '10'
-	option api_allow 'W:0/0'
-	option power_mode 'balance'
-	option pool1url 'stratum+tcp://ca.stratum.slushpool.com:3333'
-	option pool1user 'poolacct.worker1'
-	option pool2url 'stratum+tcp://ca.stratum.slushpool.com:3333'
-	option pool2user 'poolacct.worker2'
-	option pool3url 'stratum+tcp://ca.stratum.slushpool.com:3333'
-	option pool3user 'poolacct.worker3'
-	option ntp_enable 'openwrt'
-

config_tool.py

@@ -1,4 +0,0 @@
-from tools.cfg_util import main
-
-if __name__ == "__main__":
-    main()

docs/config/miner_config.md

@@ -0,0 +1,8 @@
+# pyasic
+## Miner Config
+
+::: pyasic.config.MinerConfig
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/data/error_codes.md

@@ -0,0 +1,33 @@
+# pyasic
+<br>
+
+## Whatsminer Error Codes
+::: pyasic.data.error_codes.WhatsminerError
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## Braiins OS Error Codes
+::: pyasic.data.error_codes.BraiinsOSError
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## X19 Error Codes
+::: pyasic.data.error_codes.X19Error
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## Innosilicon Error Codes
+::: pyasic.data.error_codes.InnosiliconError
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/data/miner_data.md

@@ -0,0 +1,22 @@
+# pyasic
+
+## Miner Data
+::: pyasic.data.MinerData
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## HashBoard Data
+::: pyasic.data.HashBoard
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Fan Data
+::: pyasic.data.Fan
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/generate_miners.py

@@ -0,0 +1,175 @@
+import asyncio
+import importlib
+import os
+import warnings
+
+from pyasic.miners.factory import MINER_CLASSES, MinerTypes
+
+warnings.filterwarnings("ignore")
+
+
+def path(cls):
+    module = importlib.import_module(cls.__module__)
+    return module.__name__ + "." + cls.__name__
+
+
+def make(cls):
+    p = path(cls)
+    return p.split(".")[2]
+
+
+def model_type(cls):
+    p = path(cls)
+    return p.split(".")[4]
+
+
+def backend_str(backend: MinerTypes) -> str:
+    match backend:
+        case MinerTypes.ANTMINER:
+            return "Stock Firmware Antminers"
+        case MinerTypes.AURADINE:
+            return "Stock Firmware Auradine Miners"
+        case MinerTypes.AVALONMINER:
+            return "Stock Firmware Avalonminers"
+        case MinerTypes.VNISH:
+            return "Vnish Firmware Miners"
+        case MinerTypes.EPIC:
+            return "ePIC Firmware Miners"
+        case MinerTypes.BRAIINS_OS:
+            return "BOS+ Firmware Miners"
+        case MinerTypes.HIVEON:
+            return "HiveOS Firmware Miners"
+        case MinerTypes.INNOSILICON:
+            return "Stock Firmware Innosilicons"
+        case MinerTypes.WHATSMINER:
+            return "Stock Firmware Whatsminers"
+        case MinerTypes.GOLDSHELL:
+            return "Stock Firmware Goldshells"
+        case MinerTypes.LUX_OS:
+            return "LuxOS Firmware Miners"
+        case MinerTypes.MARATHON:
+            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"
+
+
+def create_url_str(mtype: str):
+    return (
+        mtype.lower()
+        .replace(" ", "-")
+        .replace("(", "")
+        .replace(")", "")
+        .replace("+", "_1")
+    )
+
+
+HEADER_FORMAT = "# pyasic\n## {} Models\n\n"
+MINER_HEADER_FORMAT = "## {}\n"
+DATA_FORMAT = """::: {}
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+"""
+SUPPORTED_TYPES_HEADER = """# pyasic
+## Supported Miners
+
+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.
+
+##### pyasic currently supports the following miners and subtypes:
+<style>
+details {
+    margin:0px;
+    padding-top:0px;
+    padding-bottom:0px;
+}
+</style>
+"""
+BACKEND_TYPE_HEADER = """
+<details>
+<summary>{}:</summary>
+    <ul>"""
+
+MINER_TYPE_HEADER = """
+        <details>
+            <summary>{} Series:</summary>
+                <ul>"""
+
+MINER_DETAILS = """
+                    <li><a href="../{}/{}#{}">{}</a></li>"""
+
+MINER_TYPE_CLOSER = """
+                </ul>
+        </details>"""
+BACKEND_TYPE_CLOSER = """
+    </ul>
+</details>"""
+
+m_data = {}
+
+
+for m in MINER_CLASSES:
+    for t in MINER_CLASSES[m]:
+        if t is not None:
+            miner = MINER_CLASSES[m][t]
+            if make(miner) not in m_data:
+                m_data[make(miner)] = {}
+            if model_type(miner) not in m_data[make(miner)]:
+                m_data[make(miner)][model_type(miner)] = []
+            m_data[make(miner)][model_type(miner)].append(miner)
+
+
+async def create_directory_structure(directory, data):
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    for key, value in data.items():
+        subdirectory = os.path.join(directory, key)
+        if isinstance(value, dict):
+            await create_directory_structure(subdirectory, value)
+        elif isinstance(value, list):
+            file_path = os.path.join(subdirectory + ".md")
+
+            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()
+                    file.write(MINER_HEADER_FORMAT.format(header))
+                    file.write(DATA_FORMAT.format(path(item)))
+
+
+async def create_supported_types(directory):
+    with open(os.path.join(directory, "supported_types.md"), "w") as file:
+        file.write(SUPPORTED_TYPES_HEADER)
+        for mback in MINER_CLASSES:
+            backend_types = {}
+            file.write(BACKEND_TYPE_HEADER.format(backend_str(mback)))
+            for mtype in MINER_CLASSES[mback]:
+                if mtype is None:
+                    continue
+                m = MINER_CLASSES[mback][mtype]
+                if model_type(m) not in backend_types:
+                    backend_types[model_type(m)] = []
+                backend_types[model_type(m)].append(m)
+
+            for mtype in backend_types:
+                file.write(MINER_TYPE_HEADER.format(mtype))
+                for minstance in backend_types[mtype]:
+                    model = await minstance("1.1.1.1").get_model()
+                    file.write(
+                        MINER_DETAILS.format(
+                            make(minstance), mtype, create_url_str(model), model
+                        )
+                    )
+                file.write(MINER_TYPE_CLOSER)
+            file.write(BACKEND_TYPE_CLOSER)
+
+
+root_directory = os.path.join(os.getcwd(), "miners")
+asyncio.run(create_directory_structure(root_directory, m_data))
+asyncio.run(create_supported_types(root_directory))

docs/index.md

@@ -0,0 +1,280 @@
+# pyasic
+*A simplified and standardized interface for Bitcoin ASICs.*
+
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/pyasic)](https://pypi.org/project/pyasic/)
+[![Python - Supported Versions](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![CodeFactor - Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)](https://www.codefactor.io/repository/github/upstreamdata/pyasic)
+[![Commit Activity - master](https://img.shields.io/github/commit-activity/y/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/commits/master/)
+[![Code Style - Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![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`
+
+---
+## 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
+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
+
+
+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
+
+    # scan for miners asynchronously
+    # this will return the correct type of miners if they are supported with all functionality.
+    miners = await network.scan()
+    print(miners)
+
+if __name__ == "__main__":
+    asyncio.run(scan_miners())  # run the scan asynchronously with asyncio.run()
+```
+
+---
+##### 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
+
+
+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")
+    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)
+    print(miners)
+
+
+if __name__ == "__main__":
+    asyncio.run(get_miners())  # 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
+```python
+import asyncio
+from pyasic import get_miner
+
+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
+        print(miner_data.hashrate)  # hashrate of the miner in TH/s
+
+if __name__ == "__main__":
+    asyncio.run(gather_miner_data())
+```
+---
+##### 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
+
+
+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()
+
+    # 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
+
+if __name__ == "__main__":
+    asyncio.run(gather_miner_data())
+```
+
+---
+## 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].
+
+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],
+[`get_config`][pyasic.miners.base.MinerProtocol.get_config],
+[`get_data`][pyasic.miners.base.MinerProtocol.get_data],
+[`get_errors`][pyasic.miners.base.MinerProtocol.get_errors],
+[`get_hostname`][pyasic.miners.base.MinerProtocol.get_hostname],
+[`get_model`][pyasic.miners.base.MinerProtocol.get_model],
+[`reboot`][pyasic.miners.base.MinerProtocol.reboot],
+[`restart_backend`][pyasic.miners.base.MinerProtocol.restart_backend],
+[`stop_mining`][pyasic.miners.base.MinerProtocol.stop_mining],
+[`resume_mining`][pyasic.miners.base.MinerProtocol.resume_mining],
+[`is_mining`][pyasic.miners.base.MinerProtocol.is_mining],
+[`send_config`][pyasic.miners.base.MinerProtocol.send_config], and
+[`set_power_limit`][pyasic.miners.base.MinerProtocol.set_power_limit].
+
+##### Usage
+```python
+import asyncio
+from pyasic import get_miner
+
+
+async def set_fault_light():
+    miner = await get_miner("192.168.1.20")
+
+    # call control function
+    await miner.fault_light_on()
+
+if __name__ == "__main__":
+    asyncio.run(set_fault_light())
+```
+
+---
+## Helper dataclasses
+---
+
+##### [`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] is a return from the [`get_data()`](#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.
+
+[`MinerData`][pyasic.data.MinerData] instances can also be added to each other to combine their data and can be divided by a number to divide all their data, allowing you to get average data from many miners by doing -
+```python
+from pyasic import MinerData
+
+# examples of miner data
+d1 = MinerData("192.168.1.1")
+d2 = MinerData("192.168.1.2")
+
+list_of_miner_data = [d1, d2]
+
+average_data = sum(list_of_miner_data, start=MinerData("0.0.0.0"))/len(list_of_miner_data)
+```
+
+---
+
+##### [`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).
+
+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.
+
+You can use the [`MinerConfig`][pyasic.config.MinerConfig] as follows:
+```python
+import asyncio
+from pyasic import get_miner
+
+
+async def set_fault_light():
+    miner = await get_miner("192.168.1.20")
+
+    # get config
+    cfg = await miner.get_config()
+
+    # send config
+    await miner.send_config(cfg)
+
+if __name__ == "__main__":
+    asyncio.run(set_fault_light())
+
+```
+
+---
+## 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:
+
+```python
+from pyasic import settings
+
+settings.update("default_antminer_web_password", "my_pwd")
+```
+
+##### Default values:
+```
+"network_ping_retries": 1,
+"network_ping_timeout": 3,
+"network_scan_semaphore": None,
+"factory_get_retries": 1,
+"factory_get_timeout": 3,
+"get_data_retries": 1,
+"api_function_timeout": 5,
+"antminer_mining_mode_as_str": False,
+"default_whatsminer_rpc_password": "admin",
+"default_innosilicon_web_password": "admin",
+"default_antminer_web_password": "root",
+"default_bosminer_web_password": "root",
+"default_vnish_web_password": "admin",
+"default_goldshell_web_password": "123456789",
+"default_auradine_web_password": "admin",
+"default_epic_web_password": "letmein",
+"default_hive_web_password": "admin",
+"default_antminer_ssh_password": "miner",
+"default_bosminer_ssh_password": "root",
+
+# ADVANCED
+# Only use this if you know what you are doing
+"socket_linger_time": 1000,
+```

docs/miners/antminer/X15.md

@@ -0,0 +1,17 @@
+# pyasic
+## X15 Models
+
+## Z15 (Stock)
+::: pyasic.miners.antminer.cgminer.X15.Z15.CGMinerZ15
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Z15 Pro (Stock)
+::: pyasic.miners.antminer.bmminer.X15.Z15.BMMinerZ15Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X17.md

@@ -0,0 +1,115 @@
+# pyasic
+## X17 Models
+
+## S17 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17 Pro (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17e (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17+ (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17e (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17+ (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17+ (VNish)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X19.md

@@ -0,0 +1,465 @@
+# pyasic
+## X19 Models
+
+## S19 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19i (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j No PIC (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19a (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Hydro (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro+ Hydro (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T19 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19+ (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19a (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro+ (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro+ No PIC (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19k Pro No PIC (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro+ Hydro (BOS+)
+::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19ProPlusHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T19 (BOS+)
+::: pyasic.miners.antminer.bosminer.X19.T19.BOSMinerT19
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 (VNish)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro (VNish)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (VNish)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19a Pro (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19aPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro Hydro (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19ProHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T19 (VNish)
+::: pyasic.miners.antminer.vnish.X19.T19.VNishT19
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 (ePIC)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j (ePIC)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro+ (ePIC)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 XP (ePIC)
+::: pyasic.miners.antminer.epic.X19.S19.ePICS19XP
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (Stock)
+::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 (LuxOS)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (LuxOS)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19k Pro (LuxOS)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T19 (LuxOS)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro (MaraFW)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j No PIC (MaraFW)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 XP (MaraFW)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X21.md

@@ -0,0 +1,87 @@
+# pyasic
+## X21 Models
+
+## S21 (Stock)
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 Pro (Stock)
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T21 (Stock)
+::: pyasic.miners.antminer.bmminer.X21.T21.BMMinerT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 (BOS+)
+::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T21 (BOS+)
+::: pyasic.miners.antminer.bosminer.X21.T21.BOSMinerT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 (VNish)
+::: pyasic.miners.antminer.vnish.X21.S21.VNishS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 (ePIC)
+::: pyasic.miners.antminer.epic.X21.S21.ePICS21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 Pro (ePIC)
+::: pyasic.miners.antminer.epic.X21.S21.ePICS21Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T21 (ePIC)
+::: pyasic.miners.antminer.epic.X21.T21.ePICT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S21 (LuxOS)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T21 (MaraFW)
+::: pyasic.miners.antminer.marathon.X21.T21.MaraT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X3.md

@@ -0,0 +1,52 @@
+# pyasic
+## X3 Models
+
+## D3 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## L3+ (Stock)
+::: pyasic.miners.antminer.bmminer.X3.L3.BMMinerL3Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KA3 (Stock)
+::: pyasic.miners.antminer.bmminer.X3.KA3.BMMinerKA3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+::: pyasic.miners.antminer.bmminer.X3.KS3.BMMinerKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## L3+ (VNish)
+::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## L3+ (VNish)
+::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X5.md

@@ -0,0 +1,17 @@
+# pyasic
+## X5 Models
+
+## DR5 (Stock)
+::: pyasic.miners.antminer.cgminer.X5.DR5.CGMinerDR5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5 (Stock)
+::: pyasic.miners.antminer.bmminer.X5.KS5.BMMinerKS5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X7.md

@@ -0,0 +1,31 @@
+# pyasic
+## X7 Models
+
+## L7 (Stock)
+::: pyasic.miners.antminer.bmminer.X7.L7.BMMinerL7
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## K7 (Stock)
+::: pyasic.miners.antminer.bmminer.X7.K7.BMMinerK7
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## D7 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X9.md

@@ -0,0 +1,66 @@
+# pyasic
+## X9 Models
+
+## E9Pro (Stock)
+::: pyasic.miners.antminer.bmminer.X9.E9.BMMinerE9Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## D9 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S9i (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T9 (Stock)
+::: pyasic.miners.antminer.bmminer.X9.T9.BMMinerT9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S9 (BOS+)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S9 (LuxOS)
+::: pyasic.miners.antminer.luxos.X9.S9.LUXMinerS9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/auradine/AD.md

@@ -0,0 +1,24 @@
+# pyasic
+## AD Models
+
+## AT1500 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## AT2880 (Stock)
+::: pyasic.miners.auradine.flux.AD.AT2.AuradineFluxAT2880
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/auradine/AI.md

@@ -0,0 +1,17 @@
+# pyasic
+## AI Models
+
+## AI2500 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/auradine/AT.md

@@ -0,0 +1,17 @@
+# pyasic
+## AT Models
+
+## AD2500 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/avalonminer/A10X.md

@@ -0,0 +1,24 @@
+# pyasic
+## A10X Models
+
+## Avalon 1026 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Avalon 1066 (Stock)
+::: pyasic.miners.avalonminer.cgminer.A10X.A1066.CGMinerAvalon1066
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/avalonminer/A11X.md

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

docs/miners/avalonminer/A12X.md

@@ -0,0 +1,10 @@
+# pyasic
+## A12X Models
+
+## Avalon 1246 (Stock)
+::: pyasic.miners.avalonminer.cgminer.A12X.A1246.CGMinerAvalon1246
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/avalonminer/A7X.md

@@ -0,0 +1,24 @@
+# pyasic
+## A7X Models
+
+## Avalon 721 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Avalon 761 (Stock)
+::: pyasic.miners.avalonminer.cgminer.A7X.A761.CGMinerAvalon761
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/avalonminer/A8X.md

@@ -0,0 +1,24 @@
+# pyasic
+## A8X Models
+
+## Avalon 821 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Avalon 851 (Stock)
+::: pyasic.miners.avalonminer.cgminer.A8X.A851.CGMinerAvalon851
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/avalonminer/A9X.md

@@ -0,0 +1,10 @@
+# pyasic
+## A9X Models
+
+## Avalon 921 (Stock)
+::: pyasic.miners.avalonminer.cgminer.A9X.A921.CGMinerAvalon921
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/avalonminer/nano.md

@@ -0,0 +1,10 @@
+# pyasic
+## nano Models
+
+## Avalon Nano 3 (Stock)
+::: pyasic.miners.avalonminer.cgminer.nano.nano3.CGMinerAvalonNano3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/backends/bfgminer.md

@@ -0,0 +1,8 @@
+# pyasic
+## BFGMiner Backend
+
+::: pyasic.miners.backends.bfgminer.BFGMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/bmminer.md

@@ -0,0 +1,8 @@
+# pyasic
+## BMMiner Backend
+
+::: pyasic.miners.backends.bmminer.BMMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/bosminer.md

@@ -0,0 +1,16 @@
+# pyasic
+## BOSMiner Backend
+
+::: pyasic.miners.backends.braiins_os.BOSMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## BOSer Backend
+
+::: pyasic.miners.backends.braiins_os.BOSer
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/btminer.md

@@ -0,0 +1,8 @@
+# pyasic
+## BTMiner Backend
+
+::: pyasic.miners.backends.btminer.BTMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/cgminer.md

@@ -0,0 +1,8 @@
+# pyasic
+## CGMiner Backend
+
+::: pyasic.miners.backends.cgminer.CGMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/epic.md

@@ -0,0 +1,8 @@
+# pyasic
+## ePIC Backend
+
+::: pyasic.miners.backends.epic.ePIC
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/hiveon.md

@@ -0,0 +1,8 @@
+# pyasic
+## Hiveon Backend
+
+::: pyasic.miners.backends.hiveon.Hiveon
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/luxminer.md

@@ -0,0 +1,8 @@
+# pyasic
+## LUXMiner Backend
+
+::: pyasic.miners.backends.luxminer.LUXMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/backends/vnish.md

@@ -0,0 +1,8 @@
+# pyasic
+## VNish Backend
+
+::: pyasic.miners.backends.vnish.VNish
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/base_miner.md

@@ -0,0 +1,17 @@
+# pyasic
+## Base Miner
+[`BaseMiner`][pyasic.miners.base.BaseMiner] is the basis for all miner classes, they all subclass (usually indirectly) from this class.
+
+This class inherits from the [`MinerProtocol`][pyasic.miners.base.MinerProtocol], which outlines functionality for miners.
+
+You may not instantiate this class on its own, only subclass from it.
+
+::: pyasic.miners.base.BaseMiner
+    handler: python
+    options:
+        heading_level: 4
+
+::: pyasic.miners.base.MinerProtocol
+    handler: python
+    options:
+        heading_level: 4

docs/miners/bitaxe/BM.md

@@ -0,0 +1,31 @@
+# pyasic
+## BM Models
+
+## Supra (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Max (Stock)
+::: pyasic.miners.bitaxe.espminer.BM.BM1397.BitAxeMax
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Gamma (Stock)
+::: pyasic.miners.bitaxe.espminer.BM.BM1370.BitAxeGamma
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/blockminer/blockminer.md

@@ -0,0 +1,17 @@
+# pyasic
+## blockminer Models
+
+## BlockMiner 520i (ePIC)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/functions.md

@@ -0,0 +1,91 @@
+## Control functionality
+
+### Check Light
+::: pyasic.miners.base.MinerProtocol.check_light
+    handler: python
+    options:
+        heading_level: 4
+
+### Fault Light Off
+::: pyasic.miners.base.MinerProtocol.fault_light_off
+    handler: python
+    options:
+        heading_level: 4
+
+### 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
+    handler: python
+    options:
+        heading_level: 4

docs/miners/goldshell/X5.md

@@ -0,0 +1,24 @@
+# pyasic
+## X5 Models
+
+## CK5 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KD5 (Stock)
+::: pyasic.miners.goldshell.bfgminer.X5.KD5.GoldshellKD5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/goldshell/XBox.md

@@ -0,0 +1,17 @@
+# pyasic
+## XBox Models
+
+## KD Box II (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/goldshell/XMax.md

@@ -0,0 +1,10 @@
+# pyasic
+## XMax Models
+
+## KD Max (Stock)
+::: pyasic.miners.goldshell.bfgminer.XMax.KDMax.GoldshellKDMax
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/hammer/DX.md

@@ -0,0 +1,10 @@
+# pyasic
+## DX Models
+
+## D10 (Stock)
+::: 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,66 @@
+# pyasic
+## KSX Models
+
+## KS0 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS0.IceRiverKS0
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS1 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS1.IceRiverKS1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS2 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS2.IceRiverKS2
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3L (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3M (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5L (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5M (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/innosilicon/A10X.md

@@ -0,0 +1,10 @@
+# pyasic
+## A10X Models
+
+## A10X (Stock)
+::: pyasic.miners.innosilicon.cgminer.A10X.A10X.InnosiliconA10X
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/innosilicon/A11X.md

@@ -0,0 +1,17 @@
+# pyasic
+## A11X Models
+
+## A11 (Stock)
+::: pyasic.miners.innosilicon.cgminer.A11X.A11.InnosiliconA11
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A11MX (Stock)
+::: pyasic.miners.innosilicon.cgminer.A11X.A11M.InnosiliconA11MX
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/innosilicon/T3X.md

@@ -0,0 +1,10 @@
+# pyasic
+## T3X Models
+
+## T3H+ (Stock)
+::: pyasic.miners.innosilicon.cgminer.T3X.T3H.InnosiliconT3HPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/miner_factory.md

@@ -0,0 +1,36 @@
+# pyasic
+## Miner Factory
+
+[`MinerFactory`][pyasic.miners.factory.MinerFactory] is the way to create miner types in `pyasic`.  The most important method is [`get_miner()`][pyasic.get_miner], which is mapped to [`pyasic.get_miner()`][pyasic.get_miner], and should be used from there.
+
+The instance used for [`pyasic.get_miner()`][pyasic.get_miner] is `pyasic.miner_factory`.
+
+[`MinerFactory`][pyasic.miners.factory.MinerFactory] also keeps a cache, which can be cleared if needed with `pyasic.miner_factory.clear_cached_miners()`.
+
+Finally, there is functionality to get multiple miners without using `asyncio.gather()` explicitly.  Use `pyasic.miner_factory.get_multiple_miners()` with a list of IPs as strings to get a list of miner instances.  You can also get multiple miners with an `AsyncGenerator` by using `pyasic.miner_factory.get_miner_generator()`.
+
+::: pyasic.miners.factory.MinerFactory
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## Get Miner
+::: pyasic.miners.get_miner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## AnyMiner
+::: pyasic.miners.base.AnyMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+[`AnyMiner`][pyasic.miners.base.AnyMiner] is a placeholder type variable used for typing returns of functions.
+A function returning [`AnyMiner`][pyasic.miners.base.AnyMiner] will always return a subclass of [`BaseMiner`][pyasic.miners.base.BaseMiner],
+and is used to specify a function returning some arbitrary type of miner class instance.

docs/miners/supported_types.md

@@ -0,0 +1,717 @@
+# pyasic
+## Supported Miners
+
+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.
+
+##### pyasic currently supports the following miners and subtypes:
+<style>
+details {
+    margin:0px;
+    padding-top:0px;
+    padding-bottom:0px;
+}
+</style>
+
+<details>
+<summary>Stock Firmware Antminers:</summary>
+    <ul>
+        <details>
+            <summary>X3 Series:</summary>
+                <ul>
+                    <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>
+                </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>
+            <summary>X17 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X17#s17-stock">S17 (Stock)</a></li>
+                    <li><a href="../antminer/X17#s17_1-stock">S17+ (Stock)</a></li>
+                    <li><a href="../antminer/X17#s17-pro-stock">S17 Pro (Stock)</a></li>
+                    <li><a href="../antminer/X17#s17e-stock">S17e (Stock)</a></li>
+                    <li><a href="../antminer/X17#t17-stock">T17 (Stock)</a></li>
+                    <li><a href="../antminer/X17#t17_1-stock">T17+ (Stock)</a></li>
+                    <li><a href="../antminer/X17#t17e-stock">T17e (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19-stock">S19 (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19l-stock">S19L (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19-pro-stock">S19 Pro (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j-stock">S19j (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19i-stock">S19i (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19_1-stock">S19+ (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j-no-pic-stock">S19j No PIC (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19-pro_1-stock">S19 Pro+ (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-stock">S19j Pro (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19-xp-stock">S19 XP (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19a-stock">S19a (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19a-pro-stock">S19a Pro (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19-hydro-stock">S19 Hydro (Stock)</a></li>
+                    <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#t19-stock">T19 (Stock)</a></li>
+                </ul>
+        </details>
+        <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>
+    </ul>
+</details>
+<details>
+<summary>Stock Firmware Whatsminers:</summary>
+    <ul>
+        <details>
+            <summary>M2X Series:</summary>
+                <ul>
+                    <li><a href="../whatsminer/M2X#m20-v10-stock">M20 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m20s-v10-stock">M20S V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m20s-v20-stock">M20S V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m20s-v30-stock">M20S V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m20p-v10-stock">M20P V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m20p-v30-stock">M20P V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m20s_1-v30-stock">M20S+ V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m21-v10-stock">M21 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m21s-v20-stock">M21S V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m21s-v60-stock">M21S V60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m21s-v70-stock">M21S V70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m21s_1-v20-stock">M21S+ V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M2X#m29-v10-stock">M29 V10 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>M3X Series:</summary>
+                <ul>
+                    <li><a href="../whatsminer/M3X#m30-v10-stock">M30 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30-v20-stock">M30 V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30k-v10-stock">M30K V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30l-v10-stock">M30L V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v10-stock">M30S V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v20-stock">M30S V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v30-stock">M30S V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v40-stock">M30S V40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v50-stock">M30S V50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v60-stock">M30S V60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v70-stock">M30S V70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-v80-stock">M30S V80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve10-stock">M30S VE10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve20-stock">M30S VE20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve30-stock">M30S VE30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve40-stock">M30S VE40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve50-stock">M30S VE50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve60-stock">M30S VE60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-ve70-stock">M30S VE70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vf10-stock">M30S VF10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vf20-stock">M30S VF20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vf30-stock">M30S VF30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vg10-stock">M30S VG10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vg20-stock">M30S VG20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vg30-stock">M30S VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vg40-stock">M30S VG40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vh10-stock">M30S VH10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vh20-stock">M30S VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vh30-stock">M30S VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vh40-stock">M30S VH40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vh50-stock">M30S VH50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vh60-stock">M30S VH60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s-vi20-stock">M30S VI20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v10-stock">M30S+ V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v20-stock">M30S+ V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v30-stock">M30S+ V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v40-stock">M30S+ V40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v50-stock">M30S+ V50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v60-stock">M30S+ V60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v70-stock">M30S+ V70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v80-stock">M30S+ V80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v90-stock">M30S+ V90 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-v100-stock">M30S+ V100 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve30-stock">M30S+ VE30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve40-stock">M30S+ VE40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve50-stock">M30S+ VE50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve60-stock">M30S+ VE60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve70-stock">M30S+ VE70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve80-stock">M30S+ VE80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve90-stock">M30S+ VE90 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-ve100-stock">M30S+ VE100 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vf20-stock">M30S+ VF20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vf30-stock">M30S+ VF30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vg20-stock">M30S+ VG20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vg30-stock">M30S+ VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vg40-stock">M30S+ VG40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vg50-stock">M30S+ VG50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vg60-stock">M30S+ VG60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vh10-stock">M30S+ VH10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vh20-stock">M30S+ VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vh30-stock">M30S+ VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vh40-stock">M30S+ VH40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vh50-stock">M30S+ VH50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1-vh60-stock">M30S+ VH60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-v10-stock">M30S++ V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-v20-stock">M30S++ V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-ve30-stock">M30S++ VE30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-ve40-stock">M30S++ VE40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-ve50-stock">M30S++ VE50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vf40-stock">M30S++ VF40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vg30-stock">M30S++ VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vg40-stock">M30S++ VG40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vg50-stock">M30S++ VG50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh10-stock">M30S++ VH10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh20-stock">M30S++ VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh30-stock">M30S++ VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh40-stock">M30S++ VH40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh50-stock">M30S++ VH50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh60-stock">M30S++ VH60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh70-stock">M30S++ VH70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh80-stock">M30S++ VH80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh90-stock">M30S++ VH90 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vh100-stock">M30S++ VH100 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vj20-stock">M30S++ VJ20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30s_1_1-vj30-stock">M30S++ VJ30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31-v10-stock">M31 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31-v20-stock">M31 V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31h-v10-stock">M31H V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31h-v40-stock">M31H V40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m30l-v10-stock">M30L V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v10-stock">M31S V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v20-stock">M31S V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v30-stock">M31S V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v40-stock">M31S V40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v50-stock">M31S V50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v60-stock">M31S V60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v70-stock">M31S V70 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v80-stock">M31S V80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-v90-stock">M31S V90 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-ve10-stock">M31S VE10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-ve20-stock">M31S VE20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s-ve30-stock">M31S VE30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31se-v10-stock">M31SE V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31se-v20-stock">M31SE V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31se-v30-stock">M31SE V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v10-stock">M31S+ V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v20-stock">M31S+ V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v30-stock">M31S+ V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v40-stock">M31S+ V40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v50-stock">M31S+ V50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v60-stock">M31S+ V60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v80-stock">M31S+ V80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v90-stock">M31S+ V90 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-v100-stock">M31S+ V100 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve10-stock">M31S+ VE10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve20-stock">M31S+ VE20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve30-stock">M31S+ VE30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve40-stock">M31S+ VE40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve50-stock">M31S+ VE50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve60-stock">M31S+ VE60 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-ve80-stock">M31S+ VE80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-vf20-stock">M31S+ VF20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-vf30-stock">M31S+ VF30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-vg20-stock">M31S+ VG20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m31s_1-vg30-stock">M31S+ VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m32-v10-stock">M32 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m32-v20-stock">M32 V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33-v10-stock">M33 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33-v20-stock">M33 V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33-v30-stock">M33 V30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s-vg30-stock">M33S VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s_1-vg20-stock">M33S+ VG20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s_1-vh20-stock">M33S+ VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s_1-vh30-stock">M33S+ VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s_1_1-vh20-stock">M33S++ VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s_1_1-vh30-stock">M33S++ VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m33s_1_1-vg40-stock">M33S++ VG40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m34s_1-ve10-stock">M34S+ VE10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m36s-ve10-stock">M36S VE10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m36s_1-vg30-stock">M36S+ VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m36s_1_1-vh30-stock">M36S++ VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m39-v10-stock">M39 V10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m39-v20-stock">M39 V20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M3X#m39-v30-stock">M39 V30 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>M5X Series:</summary>
+                <ul>
+                    <li><a href="../whatsminer/M5X#m50-ve30-stock">M50 VE30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vg30-stock">M50 VG30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh10-stock">M50 VH10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh20-stock">M50 VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh30-stock">M50 VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh40-stock">M50 VH40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh50-stock">M50 VH50 (Stock)</a></li>
+                    <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>
+                    <li><a href="../whatsminer/M5X#m50s-vj10-stock">M50S VJ10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vj20-stock">M50S VJ20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vj30-stock">M50S VJ30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vh10-stock">M50S VH10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vh20-stock">M50S VH20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vh30-stock">M50S VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vh40-stock">M50S VH40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s-vh50-stock">M50S VH50 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s_1-vh30-stock">M50S+ VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s_1-vh40-stock">M50S+ VH40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s_1-vj30-stock">M50S+ VJ30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50s_1-vk20-stock">M50S+ VK20 (Stock)</a></li>
+                    <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#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>
+                    <li><a href="../whatsminer/M5X#m53s_1-vj30-stock">M53S+ VJ30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m53s_1_1-vk10-stock">M53S++ VK10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m56-vh30-stock">M56 VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m56s-vh30-stock">M56S VH30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m56s_1-vj30-stock">M56S+ VJ30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m59-vh30-stock">M59 VH30 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>M6X Series:</summary>
+                <ul>
+                    <li><a href="../whatsminer/M6X#m60-vk10-stock">M60 VK10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60-vk20-stock">M60 VK20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60-vk30-stock">M60 VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60-vk40-stock">M60 VK40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60s-vk10-stock">M60S VK10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60s-vk20-stock">M60S VK20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60s-vk30-stock">M60S VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m60s-vk40-stock">M60S VK40 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m63-vk10-stock">M63 VK10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m63-vk20-stock">M63 VK20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m63-vk30-stock">M63 VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m63s-vk10-stock">M63S VK10 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m63s-vk20-stock">M63S VK20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m63s-vk30-stock">M63S VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m66-vk20-stock">M66 VK20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m66-vk30-stock">M66 VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m66s-vk20-stock">M66S VK20 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m66s-vk30-stock">M66S VK30 (Stock)</a></li>
+                    <li><a href="../whatsminer/M6X#m66s-vk40-stock">M66S VK40 (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Stock Firmware Avalonminers:</summary>
+    <ul>
+        <details>
+            <summary>A7X Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/A7X#avalon-721-stock">Avalon 721 (Stock)</a></li>
+                    <li><a href="../avalonminer/A7X#avalon-741-stock">Avalon 741 (Stock)</a></li>
+                    <li><a href="../avalonminer/A7X#avalon-761-stock">Avalon 761 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>A8X Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/A8X#avalon-821-stock">Avalon 821 (Stock)</a></li>
+                    <li><a href="../avalonminer/A8X#avalon-841-stock">Avalon 841 (Stock)</a></li>
+                    <li><a href="../avalonminer/A8X#avalon-851-stock">Avalon 851 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>A9X Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/A9X#avalon-921-stock">Avalon 921 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>A10X Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/A10X#avalon-1026-stock">Avalon 1026 (Stock)</a></li>
+                    <li><a href="../avalonminer/A10X#avalon-1047-stock">Avalon 1047 (Stock)</a></li>
+                    <li><a href="../avalonminer/A10X#avalon-1066-stock">Avalon 1066 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>A11X Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/A11X#avalon-1166-pro-stock">Avalon 1166 Pro (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>A12X Series:</summary>
+                <ul>
+                    <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>
+<summary>Stock Firmware Innosilicons:</summary>
+    <ul>
+        <details>
+            <summary>T3X Series:</summary>
+                <ul>
+                    <li><a href="../innosilicon/T3X#t3h_1-stock">T3H+ (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>A10X Series:</summary>
+                <ul>
+                    <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>
+<summary>Stock Firmware Goldshells:</summary>
+    <ul>
+        <details>
+            <summary>X5 Series:</summary>
+                <ul>
+                    <li><a href="../goldshell/X5#ck5-stock">CK5 (Stock)</a></li>
+                    <li><a href="../goldshell/X5#hs5-stock">HS5 (Stock)</a></li>
+                    <li><a href="../goldshell/X5#kd5-stock">KD5 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>XMax Series:</summary>
+                <ul>
+                    <li><a href="../goldshell/XMax#kd-max-stock">KD Max (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>XBox Series:</summary>
+                <ul>
+                    <li><a href="../goldshell/XBox#kd-box-ii-stock">KD Box II (Stock)</a></li>
+                    <li><a href="../goldshell/XBox#kd-box-pro-stock">KD Box Pro (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>BOS+ Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X9 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X9#s9-bos_1">S9 (BOS+)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X17 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X17#s17-bos_1">S17 (BOS+)</a></li>
+                    <li><a href="../antminer/X17#s17_1-bos_1">S17+ (BOS+)</a></li>
+                    <li><a href="../antminer/X17#s17-pro-bos_1">S17 Pro (BOS+)</a></li>
+                    <li><a href="../antminer/X17#s17e-bos_1">S17e (BOS+)</a></li>
+                    <li><a href="../antminer/X17#t17-bos_1">T17 (BOS+)</a></li>
+                    <li><a href="../antminer/X17#t17_1-bos_1">T17+ (BOS+)</a></li>
+                    <li><a href="../antminer/X17#t17e-bos_1">T17e (BOS+)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19-bos_1">S19 (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19_1-bos_1">S19+ (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19-pro-bos_1">S19 Pro (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19a-bos_1">S19a (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19a-pro-bos_1">S19a Pro (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-bos_1">S19j (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-no-pic-bos_1">S19j No PIC (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-bos_1">S19j Pro (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-no-pic-bos_1">S19j Pro No PIC (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro_1-bos_1">S19j Pro+ (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro_1-bos_1">S19j Pro+ (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro_1-no-pic-bos_1">S19j 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#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>
+        <details>
+            <summary>X21 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X21#s21-bos_1">S21 (BOS+)</a></li>
+                    <li><a href="../antminer/X21#t21-bos_1">T21 (BOS+)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Vnish Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X3 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X3#l3_1-vnish">L3+ (VNish)</a></li>
+                    <li><a href="../antminer/X3#l3_1-vnish">L3+ (VNish)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X7 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X7#l7-vnish">L7 (VNish)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X17 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X17#s17_1-vnish">S17+ (VNish)</a></li>
+                    <li><a href="../antminer/X17#s17-pro-vnish">S17 Pro (VNish)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19-vnish">S19 (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19-no-pic-vnish">S19 No PIC (VNish)</a></li>
+                    <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#t19-vnish">T19 (VNish)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X21 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X21#s21-vnish">S21 (VNish)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>ePIC Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19-epic">S19 (ePIC)</a></li>
+                    <li><a href="../antminer/X19#s19-pro-epic">S19 Pro (ePIC)</a></li>
+                    <li><a href="../antminer/X19#s19j-epic">S19j (ePIC)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-epic">S19j Pro (ePIC)</a></li>
+                    <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>
+                </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>
+        <details>
+            <summary>blockminer Series:</summary>
+                <ul>
+                    <li><a href="../blockminer/blockminer#blockminer-520i-epic">BlockMiner 520i (ePIC)</a></li>
+                    <li><a href="../blockminer/blockminer#blockminer-720i-epic">BlockMiner 720i (ePIC)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>HiveOS Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X9 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X9#t9-stock">T9 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19j-pro-stock">S19j Pro (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>LuxOS Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X9 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X9#s9-luxos">S9 (LuxOS)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19-luxos">S19 (LuxOS)</a></li>
+                    <li><a href="../antminer/X19#s19-pro-luxos">S19 Pro (LuxOS)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-luxos">S19j Pro (LuxOS)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro_1-luxos">S19j Pro+ (LuxOS)</a></li>
+                    <li><a href="../antminer/X19#s19k-pro-luxos">S19k Pro (LuxOS)</a></li>
+                    <li><a href="../antminer/X19#s19-xp-luxos">S19 XP (LuxOS)</a></li>
+                    <li><a href="../antminer/X19#t19-luxos">T19 (LuxOS)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X21 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X21#s21-luxos">S21 (LuxOS)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Stock Firmware Auradine Miners:</summary>
+    <ul>
+        <details>
+            <summary>AD Series:</summary>
+                <ul>
+                    <li><a href="../auradine/AD#at1500-stock">AT1500 (Stock)</a></li>
+                    <li><a href="../auradine/AD#at2860-stock">AT2860 (Stock)</a></li>
+                    <li><a href="../auradine/AD#at2880-stock">AT2880 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>AI Series:</summary>
+                <ul>
+                    <li><a href="../auradine/AI#ai2500-stock">AI2500 (Stock)</a></li>
+                    <li><a href="../auradine/AI#ai3680-stock">AI3680 (Stock)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>AT Series:</summary>
+                <ul>
+                    <li><a href="../auradine/AT#ad2500-stock">AD2500 (Stock)</a></li>
+                    <li><a href="../auradine/AT#ad3500-stock">AD3500 (Stock)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Mara Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X19 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X19#s19-marafw">S19 (MaraFW)</a></li>
+                    <li><a href="../antminer/X19#s19-pro-marafw">S19 Pro (MaraFW)</a></li>
+                    <li><a href="../antminer/X19#s19j-marafw">S19j (MaraFW)</a></li>
+                    <li><a href="../antminer/X19#s19j-no-pic-marafw">S19j No PIC (MaraFW)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-marafw">S19j Pro (MaraFW)</a></li>
+                    <li><a href="../antminer/X19#s19-xp-marafw">S19 XP (MaraFW)</a></li>
+                    <li><a href="../antminer/X19#s19k-pro-marafw">S19K Pro (MaraFW)</a></li>
+                </ul>
+        </details>
+        <details>
+            <summary>X21 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X21#s21-marafw">S21 (MaraFW)</a></li>
+                    <li><a href="../antminer/X21#t21-marafw">T21 (MaraFW)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>
+<details>
+<summary>Stock Firmware BitAxe Miners:</summary>
+    <ul>
+        <details>
+            <summary>BM Series:</summary>
+                <ul>
+                    <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>

docs/miners/whatsminer/M2X.md

@@ -0,0 +1,94 @@
+# pyasic
+## M2X Models
+
+## M20 V10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20S V20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20P V10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20S+ V30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M21S V20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M21S V70 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M29 V10 (Stock)
+::: pyasic.miners.whatsminer.btminer.M2X.M29.BTMinerM29V10
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/whatsminer/M5X.md

@@ -0,0 +1,269 @@
+# pyasic
+## M5X Models
+
+## M50 VE30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VH10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VH30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VH50 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VH70 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VH90 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50 VJ20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S VJ10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S VJ30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S VH20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S VH40 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S+ VH30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S+ VJ30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S++ VK10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M50S++ VK30 (Stock)
+::: pyasic.miners.whatsminer.btminer.M5X.M50S_Plus_Plus.BTMinerM50SPlusPlusVK30
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M53 VH30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M53S VJ40 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M53S++ VK10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M56S VH30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M59 VH30 (Stock)
+::: pyasic.miners.whatsminer.btminer.M5X.M59.BTMinerM59VH30
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/whatsminer/M6X.md

@@ -0,0 +1,136 @@
+# pyasic
+## M6X Models
+
+## M60 VK10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M60 VK30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M60S VK10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M60S VK30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M63 VK10 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M63 VK30 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M63S VK20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M66 VK20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M66S VK20 (Stock)
+::: 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
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M66S VK40 (Stock)
+::: pyasic.miners.whatsminer.btminer.M6X.M66S.BTMinerM66SVK40
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/network/miner_network.md

@@ -0,0 +1,8 @@
+# pyasic
+## Miner Network
+
+::: pyasic.network.MinerNetwork
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/requirements.txt

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

docs/rpc/api.md

@@ -0,0 +1,27 @@
+# pyasic
+## Miner RPC APIs
+Each miner has a unique RPC API that is used to communicate with it.
+Each of these API types has commands that differ between them, and some commands have data that others do not.
+Each miner that is a subclass of [`BaseMiner`][pyasic.miners.base.BaseMiner] may have an API linked to it as `Miner.rpc`.
+
+All RPC API implementations inherit from [`BaseMinerRPCAPI`][pyasic.rpc.base.BaseMinerRPCAPI], which implements the basic communications protocols.
+
+[`BaseMinerRPCAPI`][pyasic.rpc.base.BaseMinerRPCAPI] should never be used unless inheriting to create a new miner API class for a new type of miner (which should be exceedingly rare).
+[`BaseMinerRPCAPI`][pyasic.rpc.base.BaseMinerRPCAPI] cannot be instantiated directly, it will raise a `TypeError`.
+Use these instead -
+
+#### [BFGMiner API][pyasic.rpc.bfgminer.BFGMinerRPCAPI]
+#### [BMMiner API][pyasic.rpc.bmminer.BMMinerRPCAPI]
+#### [BOSMiner API][pyasic.rpc.bosminer.BOSMinerRPCAPI]
+#### [BTMiner API][pyasic.rpc.btminer.BTMinerRPCAPI]
+#### [CGMiner API][pyasic.rpc.cgminer.CGMinerRPCAPI]
+#### [LUXMiner API][pyasic.rpc.luxminer.LUXMinerRPCAPI]
+#### [Unknown API][pyasic.rpc.unknown.UnknownRPCAPI]
+
+<br>
+
+## BaseMinerRPCAPI
+::: pyasic.rpc.base.BaseMinerRPCAPI
+    handler: python
+    options:
+        heading_level: 4

docs/rpc/bfgminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## BFGMinerRPCAPI
+::: pyasic.rpc.bfgminer.BFGMinerRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/rpc/bmminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## BMMinerRPCAPI
+::: pyasic.rpc.bmminer.BMMinerRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/rpc/bosminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## BOSMinerRPCAPI
+::: pyasic.rpc.bosminer.BOSMinerRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/rpc/btminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## BTMinerRPCAPI
+::: pyasic.rpc.btminer.BTMinerRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/rpc/cgminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## CGMinerRPCAPI
+::: pyasic.rpc.cgminer.CGMinerRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/rpc/luxminer.md

@@ -0,0 +1,7 @@
+# pyasic
+## LUXMinerRPCAPI
+::: pyasic.rpc.luxminer.LUXMinerRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/rpc/unknown.md

@@ -0,0 +1,7 @@
+# pyasic
+## UnknownRPCAPI
+::: pyasic.rpc.unknown.UnknownRPCAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/settings/settings.md

@@ -0,0 +1,41 @@
+# pyasic
+## settings
+
+All settings here are global settings for all of pyasic.  Set these settings with `update(key, value)`.
+
+Settings options:
+
+- `network_ping_retries`
+- `network_ping_timeout`
+- `network_scan_threads`
+- `factory_get_retries`
+- `factory_get_timeout`
+- `get_data_retries`
+- `api_function_timeout`
+- `antminer_mining_mode_as_str`
+- `default_whatsminer_rpc_password`
+- `default_innosilicon_web_password`
+- `default_antminer_web_password`
+- `default_bosminer_web_password`
+- `default_vnish_web_password`
+- `default_goldshell_web_password`
+- `default_auradine_web_password`
+- `default_epic_web_password`
+- `default_hive_web_password`
+- `default_antminer_ssh_password`
+- `default_bosminer_ssh_password`
+
+
+### get
+::: pyasic.settings.get
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+### update
+::: pyasic.settings.update
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/antminer.md

@@ -0,0 +1,14 @@
+# pyasic
+## AntminerModernWebAPI
+::: pyasic.web.antminer.AntminerModernWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## AntminerOldWebAPI
+::: pyasic.web.antminer.AntminerOldWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/api.md

@@ -0,0 +1,27 @@
+# pyasic
+## Miner Web APIs
+Each miner has a unique Web API that is used to communicate with it.
+Each of these API types has commands that differ between them, and some commands have data that others do not.
+Each miner that is a subclass of [`BaseMiner`][pyasic.miners.base.BaseMiner] may have an API linked to it as `Miner.web`.
+
+All API implementations inherit from [`BaseWebAPI`][pyasic.web.BaseWebAPI], which implements the basic communications protocols.
+
+[`BaseWebAPI`][pyasic.web.BaseWebAPI] should never be used unless inheriting to create a new miner API class for a new type of miner (which should be exceedingly rare).
+Use these instead -
+
+#### [AntminerModerNWebAPI][pyasic.web.antminer.AntminerModernWebAPI]
+#### [AntminerOldWebAPI][pyasic.web.antminer.AntminerOldWebAPI]
+#### [AuradineWebAPI][pyasic.web.auradine.AuradineWebAPI]
+#### [ePICWebAPI][pyasic.web.epic.ePICWebAPI]
+#### [GoldshellWebAPI][pyasic.web.goldshell.GoldshellWebAPI]
+#### [InnosiliconWebAPI][pyasic.web.innosilicon.InnosiliconWebAPI]
+#### [MaraWebAPI][pyasic.web.marathon.MaraWebAPI]
+#### [VNishWebAPI][pyasic.web.vnish.VNishWebAPI]
+
+<br>
+
+## BaseWebAPI
+::: pyasic.web.BaseWebAPI
+    handler: python
+    options:
+        heading_level: 4

docs/web/auradine.md

@@ -0,0 +1,7 @@
+# pyasic
+## AuradineWebAPI
+::: pyasic.web.auradine.AuradineWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/epic.md

@@ -0,0 +1,7 @@
+# pyasic
+## ePICWebAPI
+::: pyasic.web.epic.ePICWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/goldshell.md

@@ -0,0 +1,7 @@
+# pyasic
+## GoldshellWebAPI
+::: pyasic.web.goldshell.GoldshellWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/innosilicon.md

@@ -0,0 +1,7 @@
+# pyasic
+## InnosiliconWebAPI
+::: pyasic.web.innosilicon.InnosiliconWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/marathon.md

@@ -0,0 +1,7 @@
+# pyasic
+## MaraWebAPI
+::: pyasic.web.marathon.MaraWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/web/vnish.md

@@ -0,0 +1,7 @@
+# pyasic
+## VNishWebAPI
+::: pyasic.web.vnish.VNishWebAPI
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

logger/__init__.py

@@ -1,18 +0,0 @@
-import logging
-from settings import DEBUG
-
-
-logging.basicConfig(
-    # filename="logfile.txt",
-    # filemode="a",
-    format="[%(levelname)s][%(asctime)s](%(name)s) - %(message)s",
-    datefmt="%x %X",
-)
-logger = logging.getLogger()
-
-if DEBUG:
-    logger.setLevel(logging.DEBUG)
-    logging.getLogger("asyncssh").setLevel(logging.DEBUG)
-else:
-    logger.setLevel(logging.INFO)
-    logging.getLogger("asyncssh").setLevel(logging.WARNING)

make_board_tool_exe.py

@@ -1,44 +0,0 @@
-"""
-Make a build of the board tool.
-
-Usage: make_board_tool_exe.py build
-
-The build will show up in the build directory.
-"""
-import datetime
-import sys
-import os
-from cx_Freeze import setup, Executable
-
-base = None
-if sys.platform == "win32":
-    base = "Win32GUI"
-
-version = datetime.datetime.now()
-version = version.strftime("%y.%m.%d")
-print(version)
-
-
-setup(
-    name="UpstreamBoardUtil.exe",
-    version=version,
-    description="Upstream Data Board Utility Build",
-    options={
-        "build_exe": {
-            "build_exe": f"{os.getcwd()}\\build\\board_util\\UpstreamBoardUtil-{version}-{sys.platform}\\",
-            "include_files": [
-                os.path.join(os.getcwd(), "settings/settings.toml"),
-            ],
-            "include_msvcr": True,
-            "add_to_path": True,
-        },
-    },
-    executables=[
-        Executable(
-            "board_util.py",
-            base=base,
-            icon="icon.ico",
-            target_name="UpstreamBoardUtil.exe",
-        )
-    ],
-)

make_cfg_tool_exe.py

@@ -1,43 +0,0 @@
-"""
-Make a build of the config tool.
-
-Usage: make_config_tool.py build
-
-The build will show up in the build directory.
-"""
-import datetime
-import sys
-import os
-from cx_Freeze import setup, Executable
-
-base = None
-if sys.platform == "win32":
-    base = "Win32GUI"
-
-version = datetime.datetime.now()
-version = version.strftime("%y.%m.%d")
-print(version)
-
-
-setup(
-    name="UpstreamCFGUtil.exe",
-    version=version,
-    description="Upstream Data Config Utility Build",
-    options={
-        "build_exe": {
-            "build_exe": f"{os.getcwd()}\\build\\UpstreamCFGUtil-{version}-{sys.platform}\\",
-            "include_files": [
-                os.path.join(os.getcwd(), "settings/settings.toml"),
-                os.path.join(os.getcwd(), "static/CFG-Util-README.md"),
-            ],
-        },
-    },
-    executables=[
-        Executable(
-            "config_tool.py",
-            base=base,
-            icon="icon.ico",
-            target_name="UpstreamCFGUtil.exe",
-        )
-    ],
-)

miners/__init__.py

@@ -1,83 +0,0 @@
-from API.bmminer import BMMinerAPI
-from API.bosminer import BOSMinerAPI
-from API.cgminer import CGMinerAPI
-from API.btminer import BTMinerAPI
-from API.unknown import UnknownAPI
-import ipaddress
-import asyncssh
-import logging
-
-
-class BaseMiner:
-    def __init__(
-        self,
-        ip: str,
-        api: BMMinerAPI or BOSMinerAPI or CGMinerAPI or BTMinerAPI or UnknownAPI,
-    ) -> None:
-        self.ip = ipaddress.ip_address(ip)
-        self.uname = None
-        self.pwd = None
-        self.api = api
-        self.api_type = None
-        self.model = None
-        self.light = None
-        self.nominal_chips = 1
-
-    async def _get_ssh_connection(self) -> asyncssh.connect:
-        """Create a new asyncssh connection"""
-        try:
-            conn = await asyncssh.connect(
-                str(self.ip),
-                known_hosts=None,
-                username=self.uname,
-                password=self.pwd,
-                server_host_key_algs=["ssh-rsa"],
-            )
-            return conn
-        except asyncssh.misc.PermissionDenied:
-            try:
-                conn = await asyncssh.connect(
-                    str(self.ip),
-                    known_hosts=None,
-                    username="admin",
-                    password="admin",
-                    server_host_key_algs=["ssh-rsa"],
-                )
-                return conn
-            except Exception as e:
-                logging.warning(f"{self} raised an exception: {e}")
-                raise e
-        except OSError:
-            logging.warning(f"Connection refused: {self}")
-            return None
-        except Exception as e:
-            logging.warning(f"{self} raised an exception: {e}")
-            raise e
-
-    async def send_file(self, src, dest):
-        async with (await self._get_ssh_connection()) as conn:
-            await asyncssh.scp(src, (conn, dest))
-
-    async def check_light(self):
-        return self.light
-
-    async def get_board_info(self):
-        return None
-
-    async def get_config(self):
-        return None
-
-    async def get_hostname(self):
-        return None
-
-    async def get_model(self):
-        return None
-
-    async def reboot(self):
-        return None
-
-    async def restart_backend(self):
-        return None
-
-    async def send_config(self, yaml_config):
-        return None

miners/antminer/S9/bmminer.py

@@ -1,11 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-class BMMinerS9(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "S9"
-        self.api_type = "BMMiner"
-
-    def __repr__(self) -> str:
-        return f"BMMinerS9: {str(self.ip)}"

miners/antminer/S9/bosminer.py

@@ -1,15 +0,0 @@
-import logging
-import toml
-
-from miners.bosminer import BOSMiner
-from config.bos import general_config_convert_bos
-
-
-class BOSMinerS9(BOSMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "S9"
-        self.api_type = "BOSMiner"
-
-    def __repr__(self) -> str:
-        return f"BOSminerS9: {str(self.ip)}"

miners/antminer/S9/cgminer.py

@@ -1,11 +0,0 @@
-from miners.cgminer import CGMiner
-
-
-class CGMinerS9(CGMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "S9"
-        self.api_type = "CGMiner"
-
-    def __repr__(self) -> str:
-        return f"CGMinerS9: {str(self.ip)}"

miners/antminer/T9/bmminer.py

@@ -1,11 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-class BMMinerT9(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "T9"
-        self.api_type = "BMMiner"
-
-    def __repr__(self) -> str:
-        return f"BMMinerT9: {str(self.ip)}"

miners/antminer/T9/cgminer.py

@@ -1,11 +0,0 @@
-from miners.cgminer import CGMiner
-
-
-class CGMinerT9(CGMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "T9"
-        self.api_type = "CGMiner"
-
-    def __repr__(self) -> str:
-        return f"CGMinerT9: {str(self.ip)}"

miners/antminer/T9/hive.py

@@ -1,48 +0,0 @@
-from miners.bmminer import BMMiner
-
-
-class HiveonT9(BMMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.model = "T9"
-        self.api_type = "Hiveon"
-
-    def __repr__(self) -> str:
-        return f"HiveonT9: {str(self.ip)}"
-
-    async def get_board_info(self) -> dict:
-        """Gets data on each board and chain in the miner."""
-        board_stats = await self.api.stats()
-        stats = board_stats["STATS"][1]
-        boards = {}
-        board_chains = {0: [2, 9, 10], 1: [3, 11, 12], 2: [4, 13, 14]}
-        for idx, board in enumerate(board_chains):
-            boards[board] = []
-            for chain in board_chains[board]:
-                count = stats[f"chain_acn{chain}"]
-                chips = stats[f"chain_acs{chain}"].replace(" ", "")
-                if not count == 18 or "x" in chips:
-                    nominal = False
-                else:
-                    nominal = True
-                boards[board].append(
-                    {
-                        "chain": chain,
-                        "chip_count": count,
-                        "chip_status": chips,
-                        "nominal": nominal,
-                    }
-                )
-        return boards
-
-    async def get_bad_boards(self) -> dict:
-        """Checks for and provides list of non working boards."""
-        boards = await self.get_board_info()
-        bad_boards = {}
-        for board in boards.keys():
-            for chain in boards[board]:
-                if not chain["chip_count"] == 18 or "x" in chain["chip_status"]:
-                    if board not in bad_boards.keys():
-                        bad_boards[board] = []
-                    bad_boards[board].append(chain)
-        return bad_boards