version: bump version number.

docs/generate_miners.py

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

docs/miners/antminer/X19.md

@@ -127,6 +127,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S19 No PIC (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19NoPIC
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## S19 Pro (VNish)
 ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19Pro
     handler: python

docs/miners/antminer/X9.md

@@ -50,3 +50,10 @@
         show_root_heading: false
         heading_level: 4
 
+## S9 (LuxOS)
+::: pyasic.miners.antminer.luxos.X9.S9.LUXMinerS9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/supported_types.md

@@ -10,6 +10,9 @@ details {
     padding-top:0px;
     padding-bottom:0px;
 }
+ul {
+    margin:0px;
+}
 </style>
 
 <details>
@@ -419,6 +422,7 @@ details {
             <summary>X19 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X19#s19-vnish">S19 (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19-no-pic-vnish">S19 No PIC (VNish)</a></li>
                     <li><a href="../antminer/X19#s19-pro-vnish">S19 Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#s19j-vnish">S19j (VNish)</a></li>
                     <li><a href="../antminer/X19#s19j-pro-vnish">S19j Pro (VNish)</a></li>
@@ -439,4 +443,15 @@ details {
                 </ul>
         </details>
     </ul>
-</details>
+</details>
+<details>
+<summary>LuxOS Firmware Miners:</summary>
+    <ul>
+        <details>
+            <summary>X9 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X9#s9-luxos">S9 (LuxOS)</a></li>
+                </ul>
+        </details>
+    </ul>
+</details>

pyasic/miners/backends/bfgminer_goldshell.py

@@ -18,6 +18,7 @@ from typing import List, Optional
 from pyasic.config import MinerConfig
 from pyasic.data import HashBoard
 from pyasic.errors import APIError
+from pyasic.logger import logger
 from pyasic.miners.backends import BFGMiner
 from pyasic.web.goldshell import GoldshellWebAPI
 
@@ -138,7 +139,7 @@ class BFGMinerGoldshell(BFGMiner):
                         except KeyError:
                             pass
             else:
-                print(self, api_devs)
+                logger.error(self, api_devs)
 
         if not api_devdetails:
             try:
@@ -156,7 +157,7 @@ class BFGMinerGoldshell(BFGMiner):
                         except KeyError:
                             pass
             else:
-                print(self, api_devdetails)
+                logger.error(self, api_devdetails)
 
         return hashboards
 

pyasic/miners/backends/bosminer.py

@@ -174,7 +174,7 @@ BOSMINER_DATA_LOC = {
     },
     "is_mining": {
         "cmd": "is_mining",
-        "kwargs": {"api_tunerstatus": {"api": "tunerstatus"}},
+        "kwargs": {"api_devdetails": {"api": "devdetails"}},
     },
     "uptime": {
         "cmd": "get_uptime",
@@ -1072,22 +1072,16 @@ class BOSMiner(BaseMiner):
             except (IndexError, KeyError):
                 pass
 
-    async def is_mining(self, api_tunerstatus: dict = None) -> Optional[bool]:
-        if not api_tunerstatus:
+    async def is_mining(self, api_devdetails: dict = None) -> Optional[bool]:
+        if not api_devdetails:
             try:
-                api_tunerstatus = await self.api.tunerstatus()
+                api_devdetails = await self.api.send_command("devdetails", ignore_errors=True, allow_warning=False)
             except APIError:
                 pass
 
-        if api_tunerstatus:
+        if api_devdetails:
             try:
-                running = any(
-                    [
-                        d["TunerRunning"]
-                        for d in api_tunerstatus["TUNERSTATUS"][0]["TunerChainStatus"]
-                    ]
-                )
-                return running
+                return not api_devdetails["STATUS"][0]["Msg"] == "Unavailable"
             except LookupError:
                 pass
 

pyasic/miners/backends/vnish.py

@@ -17,6 +17,7 @@
 from typing import Optional
 
 from pyasic.errors import APIError
+from pyasic.logger import logger
 from pyasic.miners.backends.bmminer import BMMiner
 from pyasic.web.vnish import VNishWebAPI
 
@@ -144,7 +145,7 @@ class VNish(BMMiner):
                     float(float(api_summary["SUMMARY"][0]["GHS 5s"]) / 1000), 2
                 )
             except (IndexError, KeyError, ValueError, TypeError) as e:
-                print(e)
+                logger.error(e)
                 pass
 
     async def get_wattage_limit(self, web_settings: dict = None) -> Optional[int]:

pyasic/miners/base.py

@@ -24,6 +24,7 @@ import asyncssh
 from pyasic.config import MinerConfig
 from pyasic.data import Fan, HashBoard, MinerData
 from pyasic.data.error_codes import MinerErrorData
+from pyasic.logger import logger
 
 
 class BaseMiner(ABC):
@@ -397,7 +398,7 @@ class BaseMiner(ABC):
                     if fn_args[arg_name].get("web"):
                         web_multicommand.append(fn_args[arg_name]["web"])
             except KeyError as e:
-                print(e, data_name)
+                logger.error(e, data_name)
                 continue
 
         api_multicommand = list(set(api_multicommand))
@@ -426,23 +427,26 @@ class BaseMiner(ABC):
                 fn_args = self.data_locations[data_name]["kwargs"]
                 args_to_send = {k: None for k in fn_args}
                 for arg_name in fn_args:
-                    if fn_args[arg_name].get("api"):
-                        if api_command_data.get("multicommand"):
-                            args_to_send[arg_name] = api_command_data[
-                                fn_args[arg_name]["api"]
-                            ][0]
-                        else:
-                            args_to_send[arg_name] = api_command_data
-                    if fn_args[arg_name].get("web"):
-                        if web_command_data is not None:
-                            if web_command_data.get("multicommand"):
-                                args_to_send[arg_name] = web_command_data[
-                                    fn_args[arg_name]["web"]
-                                ]
+                    try:
+                        if fn_args[arg_name].get("api"):
+                            if api_command_data.get("multicommand"):
+                                args_to_send[arg_name] = api_command_data[
+                                    fn_args[arg_name]["api"]
+                                ][0]
                             else:
-                                if not web_command_data == {"multicommand": False}:
-                                    args_to_send[arg_name] = web_command_data
-            except (KeyError, IndexError):
+                                args_to_send[arg_name] = api_command_data
+                        if fn_args[arg_name].get("web"):
+                            if web_command_data is not None:
+                                if web_command_data.get("multicommand"):
+                                    args_to_send[arg_name] = web_command_data[
+                                        fn_args[arg_name]["web"]
+                                    ]
+                                else:
+                                    if not web_command_data == {"multicommand": False}:
+                                        args_to_send[arg_name] = web_command_data
+                    except LookupError:
+                        args_to_send[arg_name] = None
+            except LookupError as e:
                 continue
 
             function = getattr(self, self.data_locations[data_name]["cmd"])
@@ -457,8 +461,8 @@ class BaseMiner(ABC):
                     except KeyError:
                         pass
                     if len(pools_data) > 1:
-                        miner_data["pool_2_url"] = pools_data[1]["pool_2_url"]
-                        miner_data["pool_2_user"] = pools_data[1]["pool_2_user"]
+                        miner_data["pool_2_url"] = pools_data[1]["pool_1_url"]
+                        miner_data["pool_2_user"] = pools_data[1]["pool_1_user"]
                         miner_data[
                             "pool_split"
                         ] = f"{pools_data[0]['quota']}/{pools_data[1]['quota']}"

pyasic/web/bosminer.py

@@ -146,8 +146,6 @@ class BOSMinerWebAPI(BaseWebAPI):
                 data = await client.get(
                     f"http://{self.ip}{path}", headers={"User-Agent": "BTC Tools v0.1"}
                 )
-                print(data.status_code)
-                print(data.text)
                 if data.status_code == 200:
                     return data.json()
                 if ignore_errors:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.36.4"
+version = "0.36.6"
 description = "A set of modules for interfacing with many common types of ASIC bitcoin miners, using both their API and SSH."
 authors = ["UpstreamData <brett@upstreamdata.ca>"]
 repository = "https://github.com/UpstreamData/pyasic"