bump version number

This reverts commit 9da5a836ce.

.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,8 @@
+venv/
+build/
+dist/
+__pycache__/
+pyvenv.cfg
+.env/
+bin/
+lib/

.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: check-yaml
+    -   id: check-added-large-files
+-   repo: https://github.com/psf/black
+    rev: 22.6.0
+    hooks:
+    -   id: black
+-   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
+        stages: [commit]

.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/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/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")

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,31 +1,35 @@
-# minerInterface
+# pyasic
 *A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH.*
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![pypi](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![python](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![Read the Docs](https://img.shields.io/readthedocs/pyasic)](https://pyasic.readthedocs.io/en/latest/)
+[![GitHub](https://img.shields.io/github/license/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/blob/master/LICENSE.txt)
+[![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)](https://www.codefactor.io/repository/github/upstreamdata/pyasic)
+## Supported Miners
+Supported miners are listed in the docs, [here](https://pyasic.readthedocs.io/en/latest/miners/supported_types/)
+
+## Documentation
+Documentation is located on Read the Docs as [pyasic](https://pyasic.readthedocs.io/en/latest/)
+
 ## 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.
 
-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)
+### Standard Usage
+You can install pyasic directly from pip with the command `pip install pyasic`
 
-### CFG Util
-*CFG Util is a GUI for interfacing with the miners easily, it is mostly self-explanatory.*
+For those of you who aren't comfortable with code and developer tools, there are windows builds of GUI applications that use this library here -> (https://drive.google.com/drive/folders/1DjR8UOS_g0ehfiJcgmrV0FFoqFvE9akW?usp=sharing)
 
-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 -
+### Developers
+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-dev.txt``` on Windows or ```pip3 install -r requirements-dev.txt``` on Mac or UNIX if the first command fails.
 
-```python
-from tools.cfg_util import main
+You can also use poetry by initializing and running ```poetry install```, and you will have to install `pre-commit` (`pip install pre-commit`).
 
-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/147vBXbuaX85inataXeSAiKk8IKf-7xtR)
-   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.
+Finally, initialize pre-commit hooks with `pre-commit install`
 
 ### 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: 
+##### 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
@@ -43,238 +47,130 @@ To write your own custom programs with this repo, you have many options.
 
 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.
 
-A basic script to find all miners on the network and get the hashrate from them looks like this -
+There are 2 main ways to get a miner and it's functions via scanning or via the MinerFactory.
 
+#### Scanning for miners
 ```python
 import asyncio
-from network import MinerNetwork
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
+import sys
+
+from pyasic.network import MinerNetwork
+
+# Fix whatsminer bug
+# 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())
 
 
-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]
+# define asynchronous function to scan for miners
+async def scan_and_get_data():
+    # Define network range to be used for scanning
+    # This can take a list of IPs, a constructor string, or an IP and subnet mask
+    # The standard mask is /24, and you can pass any IP address in the subnet
+    net = MinerNetwork("192.168.1.69", mask=24)
+    # Scan the network for miners
+    # This function returns a list of miners of the correct type as a class
+    miners: list = await net.scan_network_for_miners()
+
+    # We can now get data from any of these miners
+    # To do them all we have to create a list of tasks and gather them
+    tasks = [miner.get_data() for miner in miners]
     # Gather all tasks asynchronously and run them
     data = await asyncio.gather(*tasks)
-    parse_tasks = []
+
+    # Data is now a list of MinerData, and we can reference any part of that
+    # Print out all data for now
     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)
+        print(item)
 
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(get_hashrate())
-```
-<br>
-You can also create your own miner without scanning if you know the IP:
-
-```python
-import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
-from tools.cfg_util_old.func.parse_data import safe_parse_api_data
-
-
-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)
-
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_hashrate(str("192.168.1.69")))
+if __name__ == "__main__":
+    asyncio.run(scan_and_get_data())
 ```
 
+</br>
 
-Now that you know that, lets move on to some common API functions that you might want to use.
-
-### Common commands:
-* Get the data used by the config utility, this includes pool data, wattage use, temperature, hashrate, etc:
-
+#### Getting a miner if you know the IP
 ```python
 import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
+import sys
+
+from pyasic.miners import get_miner
+
+# Fix whatsminer bug
+# 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())
 
 
-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 data
+# define asynchronous function to get miner and data
+async def get_miner_data(miner_ip: str):
+    # Use MinerFactory to get miner
+    # MinerFactory is a singleton, so we can just get the instance in place
+    miner = await get_miner(miner_ip)
+
+    # Get data from the miner
     data = await miner.get_data()
-    
     print(data)
 
-
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_pool_data(str("192.168.1.69")))
+if __name__ == "__main__":
+    asyncio.run(get_miner_data("192.168.1.69"))
 ```
 
+### Advanced data gathering
+
+If needed, this library exposes a wrapper for the miner API that can be used for advanced data gathering.
+
+#### List available API commands
+```python
+import asyncio
+import sys
+
+from pyasic.miners import get_miner
+
+# Fix whatsminer bug
+# 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())
 
 
-* Getting pool data:
+async def get_api_commands(miner_ip: str):
+    # Get the miner
+    miner = await get_miner(miner_ip)
+
+    # List all available commands
+    print(miner.api.get_commands())
+
+
+if __name__ == "__main__":
+    asyncio.run(get_api_commands("192.168.1.69"))
+```
+
+#### Use miner API commands to gather data
+
+The miner API commands will raise an `APIError` if they fail with a bad status code, to bypass this you must send them manually by using `miner.api.send_command(command, ignore_errors=True)`
 
 ```python
 import asyncio
-import ipaddress
-from miners.miner_factory import MinerFactory
+import sys
+
+from pyasic.miners import get_miner
+
+# Fix whatsminer bug
+# 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())
 
 
-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 = 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)
+async def get_api_commands(miner_ip: str):
+    # Get the miner
+    miner = await get_miner(miner_ip)
+
+    # Run the devdetails command
+    # This is equivalent to await miner.api.send_command("devdetails")
+    devdetails: dict = await miner.api.devdetails()
+    print(devdetails)
 
 
-if __name__ == '__main__':
-    asyncio.new_event_loop().run_until_complete(
-        get_miner_pool_data(str("192.168.1.69")))
-```
-
-* 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
-
-
-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()
-
-    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")))
-```
-
-* 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
-
-
-async def get_miner_power_data(ip: str):
-    data = None
-    # 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 = tunerstatus['TUNERSTATUS'][0]["PowerLimit"]
-    else:
-        # send the command
-        # whatsminers have the power info in summary
-        summary = await miner.api.summary()
-        # parse the return
-        data = summary['SUMMARY'][0]["Power"]
-
-    if data:
-       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_old.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 = api_data["pools"][0]["POOLS"][0]["User"]
-        print(user)
-    if "summary" in api_data.keys():
-        hashrate = 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")))
+if __name__ == "__main__":
+    asyncio.run(get_api_commands("192.168.1.69"))
 ```

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
-
-
-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)
-
-
-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/API/api.md

@@ -0,0 +1,25 @@
+# pyasic
+## Miner APIs
+Each miner has a unique 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.BaseMiner] should have an API linked to it as `Miner.api`.
+
+All API implementations inherit from [`BaseMinerAPI`][pyasic.API.BaseMinerAPI], which implements the basic communications protocols.
+
+[`BaseMinerAPI`][pyasic.API.BaseMinerAPI] should never be used unless inheriting to create a new miner API class for a new type of miner (which should be exceedingly rare).
+[`BaseMinerAPI`][pyasic.API.BaseMinerAPI] cannot be instantiated directly, it will raise a `TypeError`.
+Use these instead -
+
+#### [BMMiner API][pyasic.API.bmminer.BMMinerAPI]
+#### [BOSMiner API][pyasic.API.bosminer.BOSMinerAPI]
+#### [BTMiner API][pyasic.API.btminer.BTMinerAPI]
+#### [CGMiner API][pyasic.API.cgminer.CGMinerAPI]
+#### [Unknown API][pyasic.API.unknown.UnknownAPI]
+
+<br>
+
+## BaseMinerAPI
+::: pyasic.API.BaseMinerAPI
+    handler: python
+    options:
+        heading_level: 4

docs/API/bmminer.md

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

docs/API/bosminer.md

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

docs/API/btminer.md

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

docs/API/cgminer.md

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

docs/API/unknown.md

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

docs/config/miner_config.md

@@ -0,0 +1,24 @@
+# pyasic
+## Miner Config
+
+::: pyasic.config.MinerConfig
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Pool Groups
+
+::: pyasic.config._PoolGroup
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## Pools
+
+::: pyasic.config._Pool
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/data/error_codes.md

@@ -0,0 +1,25 @@
+# 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

docs/data/miner_data.md

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

docs/index.md

@@ -0,0 +1,103 @@
+# pyasic
+*A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH.*
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![pypi](https://img.shields.io/pypi/v/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![python](https://img.shields.io/pypi/pyversions/pyasic.svg)](https://pypi.org/project/pyasic/)
+[![Read the Docs](https://img.shields.io/readthedocs/pyasic)](https://pyasic.readthedocs.io/en/latest/)
+[![GitHub](https://img.shields.io/github/license/UpstreamData/pyasic)](https://github.com/UpstreamData/pyasic/blob/master/LICENSE.txt)
+[![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/UpstreamData/pyasic)](https://www.codefactor.io/repository/github/upstreamdata/pyasic)
+
+## Intro
+Welcome to pyasic!  Pyasic uses an asynchronous method of communicating with asic miners on your network, which makes it super fast.
+
+[Supported Miner Types](miners/supported_types.md)
+
+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.
+
+<br>
+
+## 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_network_for_miners()`][pyasic.network.MinerNetwork.scan_network_for_miners] 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("192.168.1.50")  # 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_network_for_miners()
+    print(miners)
+
+if __name__ == "__main__":
+    asyncio.run(scan_miners())  # run the scan asynchronously with asyncio.run()
+```
+
+<br>
+
+## Creating miners based on IP
+If you already know the IP address of your miner or miners, you can use the [`MinerFactory`][pyasic.miners.miner_factory.MinerFactory] to communicate and identify the miners.
+The function [`MinerFactory().get_miner()`][pyasic.miners.miner_factory.MinerFactory.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.miners.miner_factory import MinerFactory  # miner factory handles miners creation
+
+
+async def get_miners():  # define async scan function to allow awaiting
+    # get the miner with miner factory
+    # 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()
+    miner_1 = await MinerFactory().get_miner("192.168.1.75")
+    miner_2 = await MinerFactory().get_miner("192.168.1.76")
+    print(miner_1, miner_2)
+
+if __name__ == "__main__":
+    asyncio.run(get_miners())  # get the miners asynchronously with asyncio.run()
+```
+
+<br>
+
+## Getting data from miners
+
+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 a 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].
+```python
+import asyncio
+from pyasic.miners.miner_factory import MinerFactory
+
+async def gather_miner_data():
+    miner = await MinerFactory().get_miner("192.168.1.75")
+    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())
+```
+
+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("192.168.1.50")
+    miners = await network.scan_network_for_miners()
+
+    # 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())
+```

docs/miners/antminer/X17.md

@@ -0,0 +1,117 @@
+# pyasic
+## X17 Models
+
+## S17
+
+::: pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17+
+
+::: pyasic.miners.antminer.bmminer.X17.S17_Plus.BMMinerS17Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17 Pro
+
+::: pyasic.miners.antminer.bmminer.X17.S17_Pro.BMMinerS17Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17e
+
+::: pyasic.miners.antminer.bmminer.X17.S17e.BMMinerS17e
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17
+
+::: pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T17+
+
+::: pyasic.miners.antminer.bmminer.X17.T17_Plus.BMMinerT17Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## T17e
+
+::: pyasic.miners.antminer.bmminer.X17.T17e.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_Plus.BOSMinerS17Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17 Pro (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.S17_Pro.BOSMinerS17Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S17e (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.S17e.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_Plus.BOSMinerT17Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## T17e (BOS)
+
+::: pyasic.miners.antminer.bosminer.X17.T17e.BOSMinerT17e
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/antminer/X19.md

@@ -0,0 +1,94 @@
+# pyasic
+## X19 Models
+
+## S19
+
+::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19 Pro
+
+::: pyasic.miners.antminer.bmminer.X19.S19_Pro.BMMinerS19Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## S19a
+
+::: pyasic.miners.antminer.bmminer.X19.S19a.BMMinerS19a
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## S19j
+
+::: pyasic.miners.antminer.bmminer.X19.S19j.BMMinerS19j
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro
+
+::: pyasic.miners.antminer.bmminer.X19.S19j_Pro.BMMinerS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T19
+
+::: 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 Pro (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19_Pro.BOSMinerS19Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## S19j (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19j.BOSMinerS19j
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S19j Pro (BOS)
+
+::: pyasic.miners.antminer.bosminer.X19.S19j_Pro.BOSMinerS19jPro
+    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

docs/miners/antminer/X9.md

@@ -0,0 +1,36 @@
+# pyasic
+## X9 Models
+
+
+## X9 (BOS)
+
+::: pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## S9
+
+::: pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## S9i
+
+::: pyasic.miners.antminer.bmminer.X9.S9i.BMMinerS9i
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## T9
+
+::: pyasic.miners.antminer.bmminer.X9.T9.BMMinerT9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/avalonminer/A10X.md

@@ -0,0 +1,26 @@
+# pyasic
+## A10X Models
+
+## A1026
+
+::: pyasic.miners.avalonminer.cgminer.A10X.A1026.CGMinerAvalon1026
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A1047
+
+::: pyasic.miners.avalonminer.cgminer.A10X.A1047.CGMinerAvalon1047
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A1066
+
+::: pyasic.miners.avalonminer.cgminer.A10X.A1066.CGMinerAvalon1066
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/avalonminer/A7X.md

@@ -0,0 +1,26 @@
+# pyasic
+## A7X Models
+
+## A721
+
+::: pyasic.miners.avalonminer.cgminer.A7X.A721.CGMinerAvalon721
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A741
+
+::: pyasic.miners.avalonminer.cgminer.A7X.A741.CGMinerAvalon741
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A761
+
+::: 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,26 @@
+# pyasic
+## A8X Models
+
+## A821
+
+::: pyasic.miners.avalonminer.cgminer.A8X.A821.CGMinerAvalon821
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A841
+
+::: pyasic.miners.avalonminer.cgminer.A8X.A841.CGMinerAvalon841
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A851
+
+::: 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
+
+## A921
+
+::: pyasic.miners.avalonminer.cgminer.A9X.A921.CGMinerAvalon921
+    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,8 @@
+# pyasic
+## BOSMiner Backend
+
+::: pyasic.miners._backends.bosminer.BOSMiner
+    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/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/base_miner.md

@@ -0,0 +1,10 @@
+# pyasic
+## Base Miner
+[`BaseMiner`][pyasic.miners.BaseMiner] is the basis for all miner classes, they all subclass (usually indirectly) from this class.
+
+You may not instantiate this class on its own, only subclass from it.  Trying to instantiate an instance of this class will raise `TypeError`.
+
+::: pyasic.miners.BaseMiner
+    handler: python
+    options:
+        heading_level: 4

docs/miners/innosilicon/T3X.md

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

docs/miners/miner_factory.md

@@ -0,0 +1,20 @@
+# pyasic
+## Miner Factory
+
+::: pyasic.miners.miner_factory.MinerFactory
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+<br>
+
+## AnyMiner
+::: pyasic.miners.miner_factory.AnyMiner
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+[`AnyMiner`][pyasic.miners.miner_factory.AnyMiner] is a placeholder type variable used for typing returns of functions.
+A function returning [`AnyMiner`][pyasic.miners.miner_factory.AnyMiner] will always return a subclass of [`BaseMiner`][pyasic.miners.BaseMiner],
+and is used to specify a function returning some arbitrary type of miner class instance.

docs/miners/supported_types.md

@@ -0,0 +1,96 @@
+# 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:
+* Braiins OS+ Devices:
+    * X19 Series:
+        * [S19][pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19]
+        * [S19 Pro][pyasic.miners.antminer.bosminer.X19.S19_Pro.BOSMinerS19Pro]
+        * [S19j][pyasic.miners.antminer.bosminer.X19.S19j.BOSMinerS19j]
+        * [S19j Pro][pyasic.miners.antminer.bosminer.X19.S19j_Pro.BOSMinerS19jPro]
+        * [T19][pyasic.miners.antminer.bosminer.X19.T19.BOSMinerT19]
+    * X17 Series:
+        * [S17][pyasic.miners.antminer.bosminer.X17.S17.BOSMinerS17]
+        * [S17+][pyasic.miners.antminer.bosminer.X17.S17_Plus.BOSMinerS17Plus]
+        * [S17 Pro][pyasic.miners.antminer.bosminer.X17.S17_Pro.BOSMinerS17Pro]
+        * [S17e][pyasic.miners.antminer.bosminer.X17.S17e.BOSMinerS17e]
+        * [T17][pyasic.miners.antminer.bosminer.X17.T17.BOSMinerT17]
+        * [T17+][pyasic.miners.antminer.bosminer.X17.T17_Plus.BOSMinerT17Plus]
+        * [T17e][pyasic.miners.antminer.bosminer.X17.T17e.BOSMinerT17e]
+    * X9 Series:
+        * [S9][pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9]
+        * [S9i][pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9]
+        * [S9j][pyasic.miners.antminer.bosminer.X9.S9.BOSMinerS9]
+* Stock Firmware Whatsminers:
+    * M3X Series:
+        * [M30S][pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30S]:
+            * [VE10][pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SVE10]
+            * [VG20][pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SVG20]
+            * [VE20][pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SVE20]
+            * [V50][pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SV50]
+        * [M30S+][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlus]:
+            * [VF20][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlusVF20]
+            * [VE40][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlusVE40]
+            * [VG60][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlusVG60]
+        * [M30S++][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlus]:
+            * [VG30][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG30]
+            * [VG40][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG40]
+            * [VH60][pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVH60]
+        * [M31S][pyasic.miners.whatsminer.btminer.M3X.M31S.BTMinerM31S]
+        * [M31S+][pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlus]:
+            * [VE20][pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlusVE20]
+        * [M32][pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32]
+            * [V20][pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32V20]
+        * [M32S][pyasic.miners.whatsminer.btminer.M3X.M32S.BTMinerM32S]
+    * M2X Series:
+        * [M20][pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20]:
+            * [V10][pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20V10]
+        * [M20S][pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20S]:
+            * [V10][pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV10]
+            * [V20][pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV20]
+        * [M20S+][pyasic.miners.whatsminer.btminer.M2X.M20S_Plus.BTMinerM20SPlus]
+        * [M21][pyasic.miners.whatsminer.btminer.M2X.M21.BTMinerM21]
+        * [M21S][pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21S]:
+            * [V20][pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV20]
+            * [V60][pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV60]
+        * [M21S+][pyasic.miners.whatsminer.btminer.M2X.M21S_Plus.BTMinerM21SPlus]
+* Stock Firmware Antminers:
+    * X19 Series:
+        * [S19][pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19]
+        * [S19 Pro][pyasic.miners.antminer.bmminer.X19.S19_Pro.BMMinerS19Pro]
+        * [S19a][pyasic.miners.antminer.bmminer.X19.S19a.BMMinerS19a]
+        * [S19j][pyasic.miners.antminer.bmminer.X19.S19j.BMMinerS19j]
+        * [S19j Pro][pyasic.miners.antminer.bmminer.X19.S19j_Pro.BMMinerS19jPro]
+        * [T19][pyasic.miners.antminer.bmminer.X19.T19.BMMinerT19]
+    * X17 Series:
+        * [S17][pyasic.miners.antminer.bmminer.X17.S17.BMMinerS17]
+        * [S17+][pyasic.miners.antminer.bmminer.X17.S17_Plus.BMMinerS17Plus]
+        * [S17 Pro][pyasic.miners.antminer.bmminer.X17.S17_Pro.BMMinerS17Pro]
+        * [S17e][pyasic.miners.antminer.bmminer.X17.S17e.BMMinerS17e]
+        * [T17][pyasic.miners.antminer.bmminer.X17.T17.BMMinerT17]
+        * [T17+][pyasic.miners.antminer.bmminer.X17.T17_Plus.BMMinerT17Plus]
+        * [T17e][pyasic.miners.antminer.bmminer.X17.T17e.BMMinerT17e]
+    * X9 Series:
+        * [S9][pyasic.miners.antminer.bmminer.X9.S9.BMMinerS9]
+        * [S9i][pyasic.miners.antminer.bmminer.X9.S9i.BMMinerS9i]
+        * [T9][pyasic.miners.antminer.bmminer.X9.T9.BMMinerT9]
+* Stock Firmware Avalonminers:
+    * A7X Series:
+        * [A721][pyasic.miners.avalonminer.cgminer.A7X.A721.CGMinerAvalon721]
+        * [A741][pyasic.miners.avalonminer.cgminer.A7X.A741.CGMinerAvalon741]
+        * [A761][pyasic.miners.avalonminer.cgminer.A7X.A761.CGMinerAvalon761]
+    * A8X Series:
+        * [A821][pyasic.miners.avalonminer.cgminer.A8X.A821.CGMinerAvalon821]
+        * [A841][pyasic.miners.avalonminer.cgminer.A8X.A841.CGMinerAvalon841]
+        * [A851][pyasic.miners.avalonminer.cgminer.A8X.A851.CGMinerAvalon851]
+    * A9X Series:
+        * [A921][pyasic.miners.avalonminer.cgminer.A9X.A921.CGMinerAvalon921]
+    * A10X Series:
+        * [A1026][pyasic.miners.avalonminer.cgminer.A10X.A1026.CGMinerAvalon1026]
+        * [A1047][pyasic.miners.avalonminer.cgminer.A10X.A1047.CGMinerAvalon1047]
+        * [A1066][pyasic.miners.avalonminer.cgminer.A10X.A1066.CGMinerAvalon1066]
+* Stock Firmware Innosilicon Miners:
+    * T3X Series:
+        * [T3H+][pyasic.miners.innosilicon.cgminer.T3X.T3H_Plus.CGMinerInnosiliconT3HPlus]

docs/miners/whatsminer/M2X.md

@@ -0,0 +1,91 @@
+# pyasic
+## M2X Models
+
+## M20
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20V10
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20.BTMinerM20V10
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20S
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20S
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20SV10
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV10
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20SV20
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20S.BTMinerM20SV20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M20S+
+
+::: pyasic.miners.whatsminer.btminer.M2X.M20S_Plus.BTMinerM20SPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M21
+
+::: pyasic.miners.whatsminer.btminer.M2X.M21.BTMinerM21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## M21S
+
+::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21S
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M21SV20
+
+::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M21SV60
+
+::: pyasic.miners.whatsminer.btminer.M2X.M21S.BTMinerM21SV60
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M21S+
+
+::: pyasic.miners.whatsminer.btminer.M2X.M21S_Plus.BTMinerM21SPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/miners/whatsminer/M3X.md

@@ -0,0 +1,155 @@
+# pyasic
+## M3X Models
+
+## M30S
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30S
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30SVE10
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SVE10
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30SVG20
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SVG20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30SVE20
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SVE20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30SV50
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S.BTMinerM30SV50
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S+
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S+VF20
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlusVF20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S+VE40
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlusVE40
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S+VG60
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus.BTMinerM30SPlusVG60
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S++
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S++VG30
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG30
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S++VG40
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVG40
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M30S++VH60
+
+::: pyasic.miners.whatsminer.btminer.M3X.M30S_Plus_Plus.BTMinerM30SPlusPlusVH60
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+
+## M31S
+
+::: pyasic.miners.whatsminer.btminer.M3X.M31S.BTMinerM31S
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M31S+
+
+::: pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M31S+VE20
+
+::: pyasic.miners.whatsminer.btminer.M3X.M31S_Plus.BTMinerM31SPlusVE20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M32
+
+::: pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M32V20
+
+::: pyasic.miners.whatsminer.btminer.M3X.M32.BTMinerM32V20
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## M32S
+
+::: pyasic.miners.whatsminer.btminer.M3X.M32S.BTMinerM32S
+    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/network/miner_network_range.md

@@ -0,0 +1,12 @@
+# pyasic
+## Miner Network Range
+
+[`MinerNetworkRange`][pyasic.network.net_range.MinerNetworkRange] is a class used by [`MinerNetwork`][pyasic.network.MinerNetwork] to handle any constructor stings.
+The goal is to emulate what is produced by `ipaddress.ip_network` by allowing [`MinerNetwork`][pyasic.network.MinerNetwork] to get a list of hosts.
+This allows this class to be the [`MinerNetwork.network`][pyasic.network.MinerNetwork] and hence be used for scanning.
+
+::: pyasic.network.net_range.MinerNetworkRange
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4

docs/requirements.txt

@@ -0,0 +1,3 @@
+jinja2<3.1.0
+mkdocs
+mkdocstrings[python]

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_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,104 +0,0 @@
-import asyncssh
-import logging
-
-
-class BaseMiner:
-    def __init__(self, *args) -> None:
-        self.ip = None
-        self.uname = "root"
-        self.pwd = "admin"
-        self.api = None
-        self.api_type = None
-        self.model = None
-        self.light = None
-        self.hostname = None
-        self.nominal_chips = 1
-        self.version = None
-
-    def __repr__(self):
-        return f"{'' if not self.api_type else self.api_type} {'' if not self.model else self.model}: {str(self.ip)}"
-
-    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="root",
-                    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 as e:
-            logging.warning(f"Connection refused: {self}")
-            raise e
-        except Exception as e:
-            # logging.warning(f"{self} raised an exception: {e}")
-            raise e
-
-    async def fault_light_on(self) -> bool:
-        return False
-
-    async def fault_light_off(self) -> bool:
-        return False
-
-    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 False
-
-    async def restart_backend(self):
-        return False
-
-    async def send_config(self, *args, **kwargs):
-        return None
-
-    async def get_mac(self):
-        return None
-
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": "0",
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
-        return data

miners/_backends/__init__.py

@@ -1,5 +0,0 @@
-from .bmminer import BMMiner
-from .bosminer import BOSMiner
-from .btminer import BTMiner
-from .cgminer import CGMiner
-from .hiveon import Hiveon

miners/_backends/bmminer.py

@@ -1,246 +0,0 @@
-from API.bmminer import BMMinerAPI
-from miners import BaseMiner
-import logging
-from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
-
-
-class BMMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.ip = ip
-        self.api = BMMinerAPI(ip)
-        self.api_type = "BMMiner"
-        self.uname = "root"
-        self.pwd = "admin"
-
-    async def get_model(self) -> str or None:
-        """Get miner model.
-
-        :return: Miner model or None.
-        """
-        # check if model is cached
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-
-        # get devdetails data
-        version_data = await self.api.devdetails()
-
-        # if we get data back, parse it for model
-        if version_data:
-            # handle Antminer BMMiner as a base
-            self.model = version_data["DEVDETAILS"][0]["Model"].replace("Antminer ", "")
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-
-        # if we don't get devdetails, log a failed attempt
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
-    async def get_hostname(self) -> str:
-        """Get miner hostname.
-
-        :return: The hostname of the miner as a string or "?"
-        """
-        if self.hostname:
-            return self.hostname
-        try:
-            # open an ssh connection
-            async with (await self._get_ssh_connection()) as conn:
-                # if we get the connection, check hostname
-                if conn is not None:
-                    # get output of the hostname file
-                    data = await conn.run("cat /proc/sys/kernel/hostname")
-                    host = data.stdout.strip()
-
-                    # return hostname data
-                    logging.debug(f"Found hostname for {self.ip}: {host}")
-                    self.hostname = host
-                    return self.hostname
-                else:
-                    # return ? if we fail to get hostname with no ssh connection
-                    logging.warning(f"Failed to get hostname for miner: {self}")
-                    return "?"
-        except Exception as e:
-            # return ? if we fail to get hostname with an exception
-            logging.warning(f"Failed to get hostname for miner: {self}")
-            return "?"
-
-    async def send_ssh_command(self, cmd: str) -> str or None:
-        """Send a command to the miner over ssh.
-
-        :param cmd: The command to run.
-
-        :return: Result of the command or None.
-        """
-        result = None
-
-        # open an ssh connection
-        async with (await self._get_ssh_connection()) as conn:
-            # 3 retries
-            for i in range(3):
-                try:
-                    # run the command and get the result
-                    result = await conn.run(cmd)
-                    result = result.stdout
-
-                except Exception as e:
-                    # if the command fails, log it
-                    logging.warning(f"{self} command {cmd} error: {e}")
-
-                    # on the 3rd retry, return None
-                    if i == 3:
-                        return
-                    continue
-        # return the result, either command output or None
-        return result
-
-    async def get_config(self) -> list or None:
-        """Get the pool configuration of the miner.
-
-        :return: Pool config data or None.
-        """
-        # get pool data
-        pools = await self.api.pools()
-        pool_data = []
-
-        # ensure we got pool data
-        if not pools:
-            return
-
-        # parse all the pools
-        for pool in pools["POOLS"]:
-            pool_data.append({"url": pool["URL"], "user": pool["User"], "pwd": "123"})
-        return pool_data
-
-    async def reboot(self) -> bool:
-        logging.debug(f"{self}: Sending reboot command.")
-        _ret = await self.send_ssh_command("reboot")
-        logging.debug(f"{self}: Reboot command completed.")
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Total": 0,
-            "Ideal": self.nominal_chips * 3,
-            "Left Board": 0,
-            "Center Board": 0,
-            "Right Board": 0,
-            "Nominal": False,
-            "Split": "0",
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
-
-        model = await self.get_model()
-        hostname = await self.get_hostname()
-
-        if model:
-            data["Model"] = model
-
-        if hostname:
-            data["Hostname"] = hostname
-
-        miner_data = None
-        for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand("summary", "pools", "stats")
-            if miner_data:
-                break
-
-        if not miner_data:
-            return data
-
-        summary = miner_data.get("summary")[0]
-        pools = miner_data.get("pools")[0]
-        stats = miner_data.get("stats")[0]
-
-        if summary:
-            hr = summary.get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("GHS av")
-                    if hr:
-                        data["Hashrate"] = round(hr / 1000, 2)
-
-        if stats:
-            boards = stats.get("STATS")
-            if boards:
-                if len(boards) > 0:
-                    data["Left Board"] = boards[1].get("chain_acn1")
-                    data["Center Board"] = boards[1].get("chain_acn2")
-                    data["Right Board"] = boards[1].get("chain_acn3")
-                    data["Total"] = boards[1].get("total_acn")
-
-        if data["Total"] == data["Ideal"]:
-            data["Nominal"] = True
-
-        if stats:
-            temp = stats.get("STATS")
-            if temp:
-                if len(temp) > 1:
-                    for item in ["temp2", "temp1", "temp3"]:
-                        temperature = temp[1].get(item)
-                        if temperature and not temperature == 0.0:
-                            data["Temperature"] = round(temperature)
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools.get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                if pool_1.startswith("stratum+tcp://"):
-                    pool_1.replace("stratum+tcp://", "")
-                if pool_1.startswith("stratum2+tcp://"):
-                    pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = pool_1
-
-            if pool_1_user:
-                data["Pool 1 User"] = pool_1_user
-                data["Pool User"] = pool_1_user
-
-            if pool_2:
-                if pool_2.startswith("stratum+tcp://"):
-                    pool_2.replace("stratum+tcp://", "")
-                if pool_2.startswith("stratum2+tcp://"):
-                    pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = pool_2
-
-            if pool_2_user:
-                data["Pool 2 User"] = pool_2_user
-
-            if quota:
-                data["Split"] = str(quota)
-
-        return data

miners/_backends/bosminer.py

@@ -1,375 +0,0 @@
-from miners import BaseMiner
-from API.bosminer import BOSMinerAPI
-import toml
-from config.bos import bos_config_convert, general_config_convert_bos
-import logging
-from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
-
-
-class BOSMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.ip = ip
-        self.api = BOSMinerAPI(ip)
-        self.api_type = "BOSMiner"
-        self.uname = "root"
-        self.pwd = "admin"
-
-    async def send_ssh_command(self, cmd: str) -> str or None:
-        """Send a command to the miner over ssh.
-
-        :return: Result of the command or None.
-        """
-        result = None
-
-        # open an ssh connection
-        async with (await self._get_ssh_connection()) as conn:
-            # 3 retries
-            for i in range(3):
-                try:
-                    # run the command and get the result
-                    result = await conn.run(cmd)
-                    result = result.stdout
-                except Exception as e:
-                    # if the command fails, log it
-                    logging.warning(f"{self} command {cmd} error: {e}")
-
-                    # on the 3rd retry, return None
-                    if i == 3:
-                        return
-                    continue
-        # return the result, either command output or None
-        return str(result)
-
-    async def fault_light_on(self) -> bool:
-        """Sends command to turn on fault light on the miner."""
-        logging.debug(f"{self}: Sending fault_light on command.")
-        self.light = True
-        _ret = await self.send_ssh_command("miner fault_light on")
-        logging.debug(f"{self}: fault_light on command completed.")
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def fault_light_off(self) -> bool:
-        """Sends command to turn off fault light on the miner."""
-        logging.debug(f"{self}: Sending fault_light off command.")
-        self.light = False
-        _ret = await self.send_ssh_command("miner fault_light off")
-        logging.debug(f"{self}: fault_light off command completed.")
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def restart_backend(self) -> bool:
-        return await self.restart_bosminer()
-
-    async def restart_bosminer(self) -> bool:
-        """Restart bosminer hashing process."""
-        logging.debug(f"{self}: Sending bosminer restart command.")
-        _ret = await self.send_ssh_command("/etc/init.d/bosminer restart")
-        logging.debug(f"{self}: bosminer restart command completed.")
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        """Reboots power to the physical miner."""
-        logging.debug(f"{self}: Sending reboot command.")
-        _ret = await self.send_ssh_command("/sbin/reboot")
-        logging.debug(f"{self}: Reboot command completed.")
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def get_config(self) -> None:
-        logging.debug(f"{self}: Getting config.")
-        async with (await self._get_ssh_connection()) as conn:
-            logging.debug(f"{self}: Opening SFTP connection.")
-            async with conn.start_sftp_client() as sftp:
-                logging.debug(f"{self}: Reading config file.")
-                async with sftp.open("/etc/bosminer.toml") as file:
-                    toml_data = toml.loads(await file.read())
-        logging.debug(f"{self}: Converting config file.")
-        cfg = bos_config_convert(toml_data)
-        self.config = cfg
-
-    async def get_hostname(self) -> str:
-        """Get miner hostname.
-
-        :return: The hostname of the miner as a string or "?"
-        """
-        if self.hostname:
-            return self.hostname
-        try:
-            async with (await self._get_ssh_connection()) as conn:
-                if conn is not None:
-                    data = await conn.run("cat /proc/sys/kernel/hostname")
-                    host = data.stdout.strip()
-                    logging.debug(f"Found hostname for {self.ip}: {host}")
-                    self.hostname = host
-                    return self.hostname
-                else:
-                    logging.warning(f"Failed to get hostname for miner: {self}")
-                    return "?"
-        except Exception as e:
-            logging.warning(f"Failed to get hostname for miner: {self}")
-            return "?"
-
-    async def get_model(self) -> str or None:
-        """Get miner model.
-
-        :return: Miner model or None.
-        """
-        # check if model is cached
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model} (BOS)")
-            return self.model + " (BOS)"
-
-        # get devdetails data
-        version_data = await self.api.devdetails()
-
-        # if we get data back, parse it for model
-        if version_data:
-            if not version_data["DEVDETAILS"] == []:
-                # handle Antminer BOSMiner as a base
-                self.model = version_data["DEVDETAILS"][0]["Model"].replace(
-                    "Antminer ", ""
-                )
-                logging.debug(f"Found model for {self.ip}: {self.model} (BOS)")
-                return self.model + " (BOS)"
-
-        # if we don't get devdetails, log a failed attempt
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
-    async def get_version(self):
-        """Get miner firmware version.
-
-        :return: Miner firmware version or None.
-        """
-        # check if version is cached
-        if self.version:
-            logging.debug(f"Found version for {self.ip}: {self.version}")
-            return self.version
-
-        # get output of bos version file
-        version_data = await self.send_ssh_command("cat /etc/bos_version")
-
-        # if we get the version data, parse it
-        if version_data:
-            self.version = version_data.stdout.split("-")[5]
-            logging.debug(f"Found version for {self.ip}: {self.version}")
-            return self.version
-
-        # if we fail to get version, log a failed attempt
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
-    async def send_config(self, yaml_config, ip_user: bool = False) -> None:
-        """Configures miner with yaml config."""
-        logging.debug(f"{self}: Sending config.")
-        if ip_user:
-            suffix = str(self.ip).split(".")[-1]
-            toml_conf = toml.dumps(
-                general_config_convert_bos(yaml_config, user_suffix=suffix)
-            )
-        else:
-            toml_conf = toml.dumps(general_config_convert_bos(yaml_config))
-        async with (await self._get_ssh_connection()) as conn:
-            logging.debug(f"{self}: Opening SFTP connection.")
-            async with conn.start_sftp_client() as sftp:
-                logging.debug(f"{self}: Opening config file.")
-                async with sftp.open("/etc/bosminer.toml", "w+") as file:
-                    await file.write(toml_conf)
-            logging.debug(f"{self}: Restarting BOSMiner")
-            await conn.run("/etc/init.d/bosminer restart")
-
-    async def get_board_info(self) -> dict:
-        """Gets data on each board and chain in the miner."""
-        logging.debug(f"{self}: Getting board info.")
-        devdetails = await self.api.devdetails()
-        if not devdetails.get("DEVDETAILS"):
-            print("devdetails error", devdetails)
-            return {0: [], 1: [], 2: []}
-        devs = devdetails["DEVDETAILS"]
-        boards = {}
-        offset = devs[0]["ID"]
-        for board in devs:
-            boards[board["ID"] - offset] = []
-            if not board["Chips"] == self.nominal_chips:
-                nominal = False
-            else:
-                nominal = True
-            if not board["Chips"] == self.nominal_chips:
-                nominal = False
-            else:
-                nominal = True
-            boards[board["ID"] - offset].append(
-                {
-                    "chain": board["ID"] - offset,
-                    "chip_count": board["Chips"],
-                    "chip_status": "o" * board["Chips"],
-                    "nominal": nominal,
-                }
-            )
-        logging.debug(f"Found board data for {self}: {boards}")
-        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"] == 63:
-                    if board not in bad_boards.keys():
-                        bad_boards[board] = []
-                    bad_boards[board].append(chain)
-        return bad_boards
-
-    async def check_good_boards(self) -> str:
-        """Checks for and provides list for working boards."""
-        devs = await self.api.devdetails()
-        bad = 0
-        chains = devs["DEVDETAILS"]
-        for chain in chains:
-            if chain["Chips"] == 0:
-                bad += 1
-        if not bad > 0:
-            return str(self.ip)
-
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Total": 0,
-            "Ideal": self.nominal_chips * 3,
-            "Left Board": 0,
-            "Center Board": 0,
-            "Right Board": 0,
-            "Nominal": False,
-            "Split": "0",
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
-        model = await self.get_model()
-        hostname = await self.get_hostname()
-
-        if model:
-            data["Model"] = model
-
-        if hostname:
-            data["Hostname"] = hostname
-
-        miner_data = None
-        for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand(
-                "summary", "temps", "tunerstatus", "pools", "devdetails"
-            )
-            if miner_data:
-                break
-        if not miner_data:
-            return data
-        summary = miner_data.get("summary")[0]
-        temps = miner_data.get("temps")[0]
-        tunerstatus = miner_data.get("tunerstatus")[0]
-        pools = miner_data.get("pools")[0]
-        devdetails = miner_data.get("devdetails")[0]
-
-        if summary:
-            hr = summary.get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("MHS av")
-                    if hr:
-                        data["Hashrate"] = round(hr / 1000000, 2)
-
-        if temps:
-            temp = temps.get("TEMPS")
-            if temp:
-                if len(temp) > 0:
-                    temp = temp[0].get("Chip")
-                    if temp:
-                        data["Temperature"] = round(temp)
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools.get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                pool_1 = pool_1.replace("stratum+tcp://", "")
-                pool_1 = pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = pool_1
-
-            if pool_1_user:
-                data["Pool 1 User"] = pool_1_user
-                data["Pool User"] = pool_1_user
-
-            if pool_2:
-                pool_2 = pool_2.replace("stratum+tcp://", "")
-                pool_2 = pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = pool_2
-
-            if pool_2_user:
-                data["Pool 2 User"] = pool_2_user
-
-            if quota:
-                data["Split"] = str(quota)
-
-        if tunerstatus:
-            tuner = tunerstatus.get("TUNERSTATUS")
-            if tuner:
-                if len(tuner) > 0:
-                    wattage = tuner[0].get("PowerLimit")
-                    if wattage:
-                        data["Wattage"] = wattage
-
-        if devdetails:
-            boards = devdetails.get("DEVDETAILS")
-            if boards:
-                if len(boards) > 0:
-                    board_map = {0: "Left Board", 1: "Center Board", 2: "Right Board"}
-                    offset = boards[0]["ID"]
-                    for board in boards:
-                        id = board["ID"] - offset
-                        chips = board["Chips"]
-                        data["Total"] += chips
-                        data[board_map[id]] = chips
-
-        if data["Total"] == data["Ideal"]:
-            data["Nominal"] = True
-
-        return data
-
-    async def get_mac(self):
-        result = await self.send_ssh_command("cat /sys/class/net/eth0/address")
-        return result.upper()

miners/_backends/bosminer_old.py

@@ -1,46 +0,0 @@
-from miners import BaseMiner
-from API.bosminer import BOSMinerAPI
-import toml
-from config.bos import bos_config_convert, general_config_convert_bos
-import logging
-from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
-import asyncssh
-
-
-class BOSMinerOld(BaseMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.api = BOSMinerAPI(ip)
-        self.api_type = "BOSMiner"
-        self.uname = "root"
-        self.pwd = "admin"
-
-    async def send_ssh_command(self, cmd: str) -> str or None:
-        """Send a command to the miner over ssh.
-
-        :return: Result of the command or None.
-        """
-        result = None
-
-        # open an ssh connection
-        async with await asyncssh.connect("192.168.1.11", username="root") as conn:
-            # 3 retries
-            for i in range(3):
-                try:
-                    # run the command and get the result
-                    result = await conn.run(cmd)
-                    result = result.stdout
-                except Exception as e:
-                    # if the command fails, log it
-                    logging.warning(f"{self} command {cmd} error: {e}")
-
-                    # on the 3rd retry, return None
-                    if i == 3:
-                        return
-                    continue
-        # return the result, either command output or None
-        return str(result)
-
-    async def update_to_plus(self):
-        result = await self.send_ssh_command("opkg update && opkg install bos_plus")
-        return result

miners/_backends/btminer.py

@@ -1,226 +0,0 @@
-from API.btminer import BTMinerAPI
-from miners import BaseMiner
-from API import APIError
-import logging
-from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
-
-
-class BTMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.ip = ip
-        self.api = BTMinerAPI(ip)
-        self.api_type = "BTMiner"
-
-    async def get_model(self):
-        if self.model:
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-        version_data = await self.api.devdetails()
-        if version_data:
-            self.model = version_data["DEVDETAILS"][0]["Model"].split("V")[0]
-            logging.debug(f"Found model for {self.ip}: {self.model}")
-            return self.model
-        logging.warning(f"Failed to get model for miner: {self}")
-        return None
-
-    async def get_hostname(self) -> str:
-        if self.hostname:
-            return self.hostname
-        try:
-            host_data = await self.api.get_miner_info()
-            if host_data:
-                host = host_data["Msg"]["hostname"]
-                logging.debug(f"Found hostname for {self.ip}: {host}")
-                self.hostname = host
-                return self.hostname
-        except APIError:
-            logging.warning(f"Failed to get hostname for miner: {self}")
-            return "?"
-        except Exception as e:
-            logging.warning(f"Failed to get hostname for miner: {self}")
-            return "?"
-
-    async def get_board_info(self) -> dict:
-        """Gets data on each board and chain in the miner."""
-        logging.debug(f"{self}: Getting board info.")
-        devs = await self.api.devs()
-        if not devs.get("DEVS"):
-            print("devs error", devs)
-            return {0: [], 1: [], 2: []}
-        devs = devs["DEVS"]
-        boards = {}
-        offset = devs[0]["ID"]
-        for board in devs:
-            boards[board["ID"] - offset] = []
-            if "Effective Chips" in board.keys():
-                if not board["Effective Chips"] in self.nominal_chips:
-                    nominal = False
-                else:
-                    nominal = True
-                boards[board["ID"] - offset].append(
-                    {
-                        "chain": board["ID"] - offset,
-                        "chip_count": board["Effective Chips"],
-                        "chip_status": "o" * board["Effective Chips"],
-                        "nominal": nominal,
-                    }
-                )
-            else:
-                logging.warning(f"Incorrect board data from {self}: {board}")
-                print(board)
-        logging.debug(f"Found board data for {self}: {boards}")
-        return boards
-
-    async def get_mac(self):
-        mac = ""
-        data = await self.api.get_miner_info()
-        if data:
-            if "Msg" in data.keys():
-                if "mac" in data["Msg"].keys():
-                    mac = data["Msg"]["mac"]
-        return str(mac).upper()
-
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Total": 0,
-            "Ideal": self.nominal_chips * 3,
-            "Left Board": 0,
-            "Center Board": 0,
-            "Right Board": 0,
-            "Nominal": False,
-            "Split": "0",
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
-
-        try:
-            model = await self.get_model()
-            hostname = await self.get_hostname()
-        except APIError:
-            logging.warning(f"Failed to get hostname and model: {self}")
-            model = None
-            data["Model"] = "Whatsminer"
-            hostname = None
-            data["Hostname"] = "Whatsminer"
-
-        if model:
-            data["Model"] = model
-
-        if hostname:
-            data["Hostname"] = hostname
-        miner_data = None
-        for i in range(DATA_RETRIES):
-            try:
-                miner_data = await self.api.multicommand("summary", "devs", "pools")
-                if miner_data:
-                    break
-            except APIError:
-                pass
-
-        if not miner_data:
-            return data
-
-        summary = miner_data.get("summary")[0]
-        devs = miner_data.get("devs")[0]
-        pools = miner_data.get("pools")[0]
-
-        if summary:
-            summary_data = summary.get("SUMMARY")
-            if summary_data:
-                if len(summary_data) > 0:
-                    hr = summary_data[0].get("MHS av")
-                    if hr:
-                        data["Hashrate"] = round(hr / 1000000, 2)
-
-                    wattage = summary_data[0].get("Power")
-                    if wattage:
-                        data["Wattage"] = round(wattage)
-
-        if devs:
-            temp_data = devs.get("DEVS")
-            if temp_data:
-                for board in temp_data:
-                    temp = board.get("Chip Temp Avg")
-                    if temp and not temp == 0.0:
-                        data["Temperature"] = round(temp)
-                        break
-
-        if devs:
-            boards = devs.get("DEVS")
-            if boards:
-                if len(boards) > 0:
-                    board_map = {0: "Left Board", 1: "Center Board", 2: "Right Board"}
-                    if "ID" in boards[0].keys():
-                        id_key = "ID"
-                    else:
-                        id_key = "ASC"
-                    offset = boards[0][id_key]
-                    for board in boards:
-                        id = board[id_key] - offset
-                        chips = board["Effective Chips"]
-                        data["Total"] += chips
-                        data[board_map[id]] = chips
-
-        if data["Total"] == data["Ideal"]:
-            data["Nominal"] = True
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools.get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                if pool_1.startswith("stratum+tcp://"):
-                    pool_1.replace("stratum+tcp://", "")
-                if pool_1.startswith("stratum2+tcp://"):
-                    pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = pool_1
-
-            if pool_1_user:
-                data["Pool 1 User"] = pool_1_user
-                data["Pool User"] = pool_1_user
-
-            if pool_2:
-                if pool_2.startswith("stratum+tcp://"):
-                    pool_2.replace("stratum+tcp://", "")
-                if pool_2.startswith("stratum2+tcp://"):
-                    pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = pool_2
-
-            if pool_2_user:
-                data["Pool 2 User"] = pool_2_user
-
-            if quota:
-                data["Split"] = str(quota)
-
-        return data

miners/_backends/cgminer.py

@@ -1,207 +0,0 @@
-from miners import BaseMiner
-from API.cgminer import CGMinerAPI
-from API import APIError
-from settings import MINER_FACTORY_GET_VERSION_RETRIES as DATA_RETRIES
-import logging
-
-
-class CGMiner(BaseMiner):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.ip = ip
-        self.api = CGMinerAPI(ip)
-        self.api_type = "CGMiner"
-        self.uname = "root"
-        self.pwd = "admin"
-
-    async def get_model(self):
-        if self.model:
-            return self.model
-        try:
-            version_data = await self.api.devdetails()
-        except APIError:
-            return None
-        if version_data:
-            self.model = version_data["DEVDETAILS"][0]["Model"].replace("Antminer ", "")
-            return self.model
-        return None
-
-    async def get_hostname(self) -> str:
-        if self.hostname:
-            return self.hostname
-        try:
-            async with (await self._get_ssh_connection()) as conn:
-                if conn is not None:
-                    data = await conn.run("cat /proc/sys/kernel/hostname")
-                    host = data.stdout.strip()
-                    self.hostname = host
-                    return self.hostname
-                else:
-                    return "?"
-        except Exception:
-            return "?"
-
-    async def send_ssh_command(self, cmd):
-        result = None
-        async with (await self._get_ssh_connection()) as conn:
-            for i in range(3):
-                try:
-                    result = await conn.run(cmd)
-                    result = result.stdout
-                except Exception as e:
-                    print(f"{cmd} error: {e}")
-                    if i == 3:
-                        return
-                    continue
-        return result
-
-    async def restart_backend(self) -> bool:
-        return await self.restart_cgminer()
-
-    async def restart_cgminer(self) -> bool:
-        commands = ["cgminer-api restart", "/usr/bin/cgminer-monitor >/dev/null 2>&1"]
-        commands = ";".join(commands)
-        _ret = await self.send_ssh_command(commands)
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def reboot(self) -> bool:
-        logging.debug(f"{self}: Sending reboot command.")
-        _ret = await self.send_ssh_command("reboot")
-        logging.debug(f"{self}: Reboot command completed.")
-        if isinstance(_ret, str):
-            return True
-        return False
-
-    async def start_cgminer(self) -> None:
-        commands = [
-            "mkdir -p /etc/tmp/",
-            'echo "*/3 * * * * /usr/bin/cgminer-monitor" > /etc/tmp/root',
-            "crontab -u root /etc/tmp/root",
-            "/usr/bin/cgminer-monitor >/dev/null 2>&1",
-        ]
-        commands = ";".join(commands)
-        await self.send_ssh_command(commands)
-
-    async def stop_cgminer(self) -> None:
-        commands = [
-            "mkdir -p /etc/tmp/",
-            'echo "" > /etc/tmp/root',
-            "crontab -u root /etc/tmp/root",
-            "killall cgminer",
-        ]
-        commands = ";".join(commands)
-        await self.send_ssh_command(commands)
-
-    async def get_config(self) -> None:
-        async with (await self._get_ssh_connection()) as conn:
-            command = "cat /etc/config/cgminer"
-            result = await conn.run(command, check=True)
-            self.config = result.stdout
-            print(str(self.config))
-
-    async def get_data(self):
-        data = {
-            "IP": str(self.ip),
-            "Model": "Unknown",
-            "Hostname": "Unknown",
-            "Hashrate": 0,
-            "Temperature": 0,
-            "Pool User": "Unknown",
-            "Wattage": 0,
-            "Split": 0,
-            "Pool 1": "Unknown",
-            "Pool 1 User": "Unknown",
-            "Pool 2": "",
-            "Pool 2 User": "",
-        }
-
-        model = await self.get_model()
-        hostname = await self.get_hostname()
-
-        if model:
-            data["Model"] = model
-
-        if hostname:
-            data["Hostname"] = hostname
-        miner_data = None
-        for i in range(DATA_RETRIES):
-            miner_data = await self.api.multicommand("summary", "pools", "stats")
-            if miner_data:
-                break
-
-        if not miner_data:
-            return data
-
-        summary = miner_data.get("summary")[0]
-        pools = miner_data.get("pools")[0]
-        stats = miner_data.get("stats")[0]
-
-        if summary:
-            hr = summary.get("SUMMARY")
-            if hr:
-                if len(hr) > 0:
-                    hr = hr[0].get("GHS av")
-                    if hr:
-                        data["Hashrate"] = round(hr / 1000, 2)
-
-        if stats:
-            temp = stats.get("STATS")
-            if temp:
-                if len(temp) > 1:
-                    for item in ["temp2", "temp1", "temp3"]:
-                        temperature = temp[1].get(item)
-                        if temperature and not temperature == 0.0:
-                            data["Temperature"] = round(temperature)
-
-        if pools:
-            pool_1 = None
-            pool_2 = None
-            pool_1_user = None
-            pool_2_user = None
-            pool_1_quota = 1
-            pool_2_quota = 1
-            quota = 0
-            for pool in pools.get("POOLS"):
-                if not pool_1_user:
-                    pool_1_user = pool.get("User")
-                    pool_1 = pool["URL"]
-                    pool_1_quota = pool["Quota"]
-                elif not pool_2_user:
-                    pool_2_user = pool.get("User")
-                    pool_2 = pool["URL"]
-                    pool_2_quota = pool["Quota"]
-                if not pool.get("User") == pool_1_user:
-                    if not pool_2_user == pool.get("User"):
-                        pool_2_user = pool.get("User")
-                        pool_2 = pool["URL"]
-                        pool_2_quota = pool["Quota"]
-            if pool_2_user and not pool_2_user == pool_1_user:
-                quota = f"{pool_1_quota}/{pool_2_quota}"
-
-            if pool_1:
-                if pool_1.startswith("stratum+tcp://"):
-                    pool_1.replace("stratum+tcp://", "")
-                if pool_1.startswith("stratum2+tcp://"):
-                    pool_1.replace("stratum2+tcp://", "")
-                data["Pool 1"] = pool_1
-
-            if pool_1_user:
-                data["Pool 1 User"] = pool_1_user
-                data["Pool User"] = pool_1_user
-
-            if pool_2:
-                if pool_2.startswith("stratum+tcp://"):
-                    pool_2.replace("stratum+tcp://", "")
-                if pool_2.startswith("stratum2+tcp://"):
-                    pool_2.replace("stratum2+tcp://", "")
-                data["Pool 2"] = pool_2
-
-            if pool_2_user:
-                data["Pool 2 User"] = pool_2_user
-
-            if quota:
-                data["Split"] = str(quota)
-
-        return data

miners/_types/__init__.py

@@ -1,3 +0,0 @@
-from .antminer import *
-from .avalonminer import *
-from .whatsminer import *

miners/_types/antminer/X17/S17.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S17(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S17"
-        self.nominal_chips = 48

miners/_types/antminer/X17/S17_Plus.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S17Plus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S17+"
-        self.nominal_chips = 65

miners/_types/antminer/X17/S17_Pro.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S17Pro(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S17 Pro"
-        self.nominal_chips = 48

miners/_types/antminer/X17/S17e.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S17e(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S17e"
-        self.nominal_chips = 135

miners/_types/antminer/X17/T17.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class T17(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "T17"
-        self.nominal_chips = 30

miners/_types/antminer/X17/T17_Plus.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class T17Plus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "T17+"
-        self.nominal_chips = 44

miners/_types/antminer/X17/T17e.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class T17e(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "T17e"
-        self.nominal_chips = 78

miners/_types/antminer/X17/__init__.py

@@ -1,8 +0,0 @@
-from .S17 import S17
-from .S17_Plus import S17Plus
-from .S17_Pro import S17Pro
-from .S17e import S17e
-
-from .T17 import T17
-from .T17_Plus import T17Plus
-from .T17e import T17e

miners/_types/antminer/X19/S19.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S19(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S19"
-        self.nominal_chips = 76

miners/_types/antminer/X19/S19_Pro.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S19Pro(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S19 Pro"
-        self.nominal_chips = 114

miners/_types/antminer/X19/S19a.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S19a(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S19a"
-        self.nominal_chips = 72

miners/_types/antminer/X19/S19j.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S19j(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S19j"
-        self.nominal_chips = 114

miners/_types/antminer/X19/S19j_Pro.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S19jPro(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S19j Pro"
-        self.nominal_chips = 126

miners/_types/antminer/X19/T19.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class T19(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "T19"
-        self.nominal_chips = 76

miners/_types/antminer/X19/__init__.py

@@ -1,9 +0,0 @@
-from .S19 import S19
-from .S19_Pro import S19Pro
-
-from .S19j import S19j
-from .S19j_Pro import S19jPro
-
-from .S19a import S19a
-
-from .T19 import T19

miners/_types/antminer/X9/S9.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class S9(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "S9"
-        self.nominal_chips = 63

miners/_types/antminer/X9/T9.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class T9(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "T9"
-        self.nominal_chips = 57

miners/_types/antminer/X9/__init__.py

@@ -1,2 +0,0 @@
-from .S9 import S9
-from .T9 import T9

miners/_types/antminer/__init__.py

@@ -1,3 +0,0 @@
-from .X9 import *
-from .X17 import *
-from .X19 import *

miners/_types/avalonminer/A10X/A1047.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class Avalon1047(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "Avalon 1047"
-        self.nominal_chips = 114

miners/_types/avalonminer/A10X/A1066.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class Avalon1066(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "Avalon 1066"
-        self.nominal_chips = 114

miners/_types/avalonminer/A10X/__init__.py

@@ -1,2 +0,0 @@
-from .A1047 import Avalon1047
-from .A1066 import Avalon1066

miners/_types/avalonminer/A8X/A821.py

@@ -1,8 +0,0 @@
-from miners import BaseMiner
-
-
-class Avalon821(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "Avalon 821"

miners/_types/avalonminer/A8X/A841.py

@@ -1,8 +0,0 @@
-from miners import BaseMiner
-
-
-class Avalon841(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "Avalon 841"

miners/_types/avalonminer/A8X/__init__.py

@@ -1,2 +0,0 @@
-from .A821 import Avalon821
-from .A841 import Avalon841

miners/_types/avalonminer/__init__.py

@@ -1,2 +0,0 @@
-from .A8X import *
-from .A10X import *

miners/_types/whatsminer/M2X/M20S.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M20S(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M20S"
-        self.nominal_chips = 66

miners/_types/whatsminer/M2X/M20S_Plus.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M20SPlus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M20S+"
-        self.nominal_chips = 66

miners/_types/whatsminer/M2X/M21.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M21(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M21"
-        self.nominal_chips = 105

miners/_types/whatsminer/M2X/M21S.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M21S(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M21S"
-        self.nominal_chips = 105

miners/_types/whatsminer/M2X/M21S_Plus.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M21SPlus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M21S+"
-        self.nominal_chips = 105

miners/_types/whatsminer/M2X/__init__.py

@@ -1,6 +0,0 @@
-from .M20S import M20S
-from .M20S_Plus import M20SPlus
-
-from .M21 import M21
-from .M21S import M21S
-from .M21S_Plus import M21SPlus

miners/_types/whatsminer/M3X/M30S.py

@@ -1,8 +0,0 @@
-from miners import BaseMiner
-
-
-class M30S(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M30S"

miners/_types/whatsminer/M3X/M30S_Plus.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M30SPlus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M30S+"
-        self.nominal_chips = 156

miners/_types/whatsminer/M3X/M30S_Plus_Plus.py

@@ -1,12 +0,0 @@
-from miners import BaseMiner
-
-
-class M30SPlusPlus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M30S++"
-        self.nominal_chips = 117
-
-
-# TODO: handle different chip counts, 111, 117,(128)

miners/_types/whatsminer/M3X/M31S.py

@@ -1,8 +0,0 @@
-from miners import BaseMiner
-
-
-class M31S(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M31S"

miners/_types/whatsminer/M3X/M31S_Plus.py

@@ -1,8 +0,0 @@
-from miners import BaseMiner
-
-
-class M31SPlus(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M31S+"

miners/_types/whatsminer/M3X/M32S.py

@@ -1,9 +0,0 @@
-from miners import BaseMiner
-
-
-class M32S(BaseMiner):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip = ip
-        self.model = "M32S"
-        self.nominal_chips = 78

miners/_types/whatsminer/M3X/__init__.py

@@ -1,8 +0,0 @@
-from .M30S import M30S
-from .M30S_Plus import M30SPlus
-from .M30S_Plus_Plus import M30SPlusPlus
-
-from .M31S import M31S
-from .M31S_Plus import M31SPlus
-
-from .M32S import M32S

miners/_types/whatsminer/__init__.py

@@ -1,2 +0,0 @@
-from .M2X import *
-from .M3X import *

miners/antminer/__init__.py

@@ -1,4 +0,0 @@
-from .bmminer import *
-from .bosminer import *
-from .cgminer import *
-from .hiveon import *

miners/antminer/bmminer/X17/S17.py

@@ -1,8 +0,0 @@
-from miners._backends import BMMiner
-from miners._types import S17
-
-
-class BMMinerS17(BMMiner, S17):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.ip = ip

miners/antminer/bmminer/X17/S17_Plus.py

@@ -1,8 +0,0 @@
-from miners._backends import BMMiner
-from miners._types import S17Plus
-
-
-class BMMinerS17Plus(BMMiner, S17Plus):
-    def __init__(self, ip: str) -> None:
-        super().__init__(ip)
-        self.ip = ip