pyasic-umhost 0.2.3.dev16__tar.gz → 0.2.4.dev2__tar.gz

{pyasic_umhost-0.2.3.dev16 → pyasic_umhost-0.2.4.dev2}/PKG-INFO

@@ -1,9 +1,8 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: pyasic-umhost
-Version: 0.2.3.dev16
-Summary: A simplified and standardized interface for Bitcoin ASICs.
+Version: 0.2.4.dev2
+Summary: Fork of pyasic — a simplified and standardized interface for Bitcoin ASICs.
 License: Apache 2.0
-License-File: LICENSE.txt
 Keywords: python,asic,bitcoin,whatsminer,antminer,braiins-os,vnish,luxos
 Author: UpstreamData
 Author-email: brett@upstreamdata.ca

{pyasic_umhost-0.2.3.dev16 → pyasic_umhost-0.2.4.dev2}/pyasic/miners/backends/antminer.py

@@ -17,7 +17,7 @@
 import logging
 from pathlib import Path
 
-from pyasic.config import MinerConfig, MiningModeConfig, PoolConfig
+from pyasic.config import MinerConfig, MiningModeConfig, MiningModeSleep, PoolConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import X19Error
 from pyasic.data.pools import PoolMetrics, PoolUrl
@@ -227,13 +227,20 @@ class AntminerModern(BMMiner):
         return False
 
     async def stop_mining(self) -> bool:
+        # send_config -> set_miner_conf.cgi на стоковой прошивке Antminer
+        # применяется через системный reboot. Не пушим конфиг, если режим
+        # уже sleep — иначе получим лишнюю перезагрузку устройства.
         cfg = await self.get_config()
+        if isinstance(cfg.mining_mode, MiningModeSleep):
+            return True
         cfg.mining_mode = MiningModeConfig.sleep()
         await self.send_config(cfg)
         return True
 
     async def resume_mining(self) -> bool:
         cfg = await self.get_config()
+        if not isinstance(cfg.mining_mode, MiningModeSleep):
+            return True
         cfg.mining_mode = MiningModeConfig.normal()
         await self.send_config(cfg)
         return True

{pyasic_umhost-0.2.3.dev16 → pyasic_umhost-0.2.4.dev2}/pyasic/miners/backends/avalonminer.py

@@ -17,7 +17,7 @@ import copy
 import re
 import time
 
-import requests
+import httpx
 
 from pyasic.config import PoolConfig
 from pyasic.data import Fan, HashBoard
@@ -159,6 +159,11 @@ class AvalonMiner(CGMiner):
         return False
 
     async def resume_mining(self) -> bool:
+        # ascset(0, "reboot", 1) перезагружает MM-контроллер Avalon
+        # (BOOTBY = AM_BOOTBY_API). Шлём только если устройство реально
+        # в SoftOFF — иначе это бессмысленный ребут уже мающего майнера.
+        if not await self._is_sleep():
+            return True
         try:
             data = await self.rpc.ascset(0, f"reboot", 1)
         except APIError:
@@ -559,19 +564,14 @@ class AvalonMiner(CGMiner):
             return None
 
     async def set_pools(self, pools: PoolConfig) -> bool:
-        """Настройка пулов на Avalon 1346 через cgconf.cgi (синхронная версия)"""
+        """Настройка пулов на Avalon через cgconf.cgi."""
         try:
-            # Получаем список пулов
             all_pools = []
             for group in pools.groups:
                 all_pools.extend(group.pools)
-
-            # Берем первые 3 пула
             active_pools = all_pools[:3]
 
-            # Формируем данные
-            form_data = {}
-
+            form_data: dict[str, str] = {}
             for i in range(3):
                 idx = i + 1
                 if i < len(active_pools):
@@ -587,24 +587,19 @@ class AvalonMiner(CGMiner):
             form_data["mode"] = "1"
             form_data["power_level"] = "0"
 
-            # Отправляем POST запрос
             url = f"http://{self.ip}/cgconf.cgi"
-
             headers = {
                 "Content-Type": "application/x-www-form-urlencoded",
                 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
                 "Origin": f"http://{self.ip}",
-                "Referer": f"http://{self.ip}/"
+                "Referer": f"http://{self.ip}/",
             }
 
             try:
-                response = requests.post(url, data=form_data, headers=headers, timeout=10)
-
-                if response.status_code == 200:
-                    return True
-                else:
-                    return False
-            except Exception:
+                async with httpx.AsyncClient(timeout=10) as client:
+                    response = await client.post(url, data=form_data, headers=headers)
+                return response.status_code == 200
+            except httpx.HTTPError:
                 return False
 
         except Exception:

{pyasic_umhost-0.2.3.dev16 → pyasic_umhost-0.2.4.dev2}/pyasic/miners/backends/btminer.py

@@ -21,7 +21,6 @@ import semver
 from playwright.async_api import async_playwright
 
 from pyasic import settings
-from pyasic.rpc.cgminer import CGMinerRPCAPI
 from pyasic.config import MinerConfig, MiningModeConfig, PoolConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import MinerErrorData, WhatsminerError
@@ -31,6 +30,7 @@ from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
 from pyasic.rpc.btminer import BTMinerRPCAPI, BTMinerV3RPCAPI
+from pyasic.rpc.cgminer import CGMinerRPCAPI
 
 
 class BTMiner(StockFirmware):
@@ -113,6 +113,13 @@ BTMINER_DATA_LOC = DataLocations(
             "_get_serial_number",
             [RPCAPICommand("rpc_get_miner_info", "get_miner_info")],
         ),
+        str(DataOptions.PSU_SERIAL_NUMBER): DataFunction(
+            "_get_psu_serial_number",
+            [
+                RPCAPICommand("rpc_get_psu", "get_psu"),
+                RPCAPICommand("rpc_get_miner_info", "get_miner_info"),
+            ],
+        ),
         str(DataOptions.FANS): DataFunction(
             "_get_fans",
             [
@@ -649,6 +656,40 @@ class BTMinerV2(StockFirmware):
                 pass
         return None
 
+    async def _get_psu_serial_number(
+        self,
+        rpc_get_psu: dict | None = None,
+        rpc_get_miner_info: dict | None = None,
+    ) -> str | None:
+        if rpc_get_psu is None:
+            try:
+                rpc_get_psu = await self.rpc.get_psu()
+            except APIError:
+                pass
+
+        if rpc_get_psu is not None:
+            try:
+                sn = rpc_get_psu["Msg"]["serial_no"]
+                if sn:
+                    return sn
+            except LookupError:
+                pass
+
+        if rpc_get_miner_info is None:
+            try:
+                rpc_get_miner_info = await self.rpc.get_miner_info()
+            except APIError:
+                pass
+
+        if rpc_get_miner_info is not None:
+            try:
+                sn = rpc_get_miner_info["Msg"]["powersn"]
+                if sn:
+                    return sn
+            except LookupError:
+                pass
+        return None
+
     async def _get_expected_hashrate(
         self, rpc_summary: dict | None = None
     ) -> AlgoHashRateType | None:
@@ -894,7 +935,8 @@ BTMINERV3_DATA_LOC = DataLocations(
             [RPCAPICommand("rpc_get_miner_status_summary", "get.miner.status:summary")],
         ),
         str(DataOptions.FAN_PSU): DataFunction(
-            "_get_psu_fans", [RPCAPICommand("rpc_get_device_info", "get.device.info")]
+
+            "_get_fan_psu", [RPCAPICommand("rpc_get_device_info", "get.device.info")]
         ),
         str(DataOptions.ERRORS): DataFunction(
             "_get_errors",
@@ -1169,16 +1211,25 @@ class BTMinerV3(StockFirmware):
                 fans.append(Fan(speed=rpm))
         return fans
 
-    async def _get_psu_fans(self, rpc_get_device_info: dict | None = None) -> list[Fan]:
+    async def _get_fan_psu(
+        self, rpc_get_device_info: dict | None = None
+    ) -> int | None:
         if rpc_get_device_info is None:
             try:
                 rpc_get_device_info = await self.rpc.get_device_info()
             except APIError:
-                return []
-        if rpc_get_device_info is None:
-            return []
-        rpm = rpc_get_device_info.get("msg", {}).get("power", {}).get("fanspeed")
-        return [Fan(speed=rpm)] if rpm is not None else []
+                return None
+        if not isinstance(rpc_get_device_info, dict):
+            return None
+        rpm = (
+            rpc_get_device_info.get("msg", {}).get("power", {}).get("fanspeed")
+        )
+        if rpm is None:
+            return None
+        try:
+            return int(rpm)
+        except (TypeError, ValueError):
+            return None
 
     async def _get_errors(
         self, rpc_get_device_info: dict | None = None
@@ -1508,7 +1559,7 @@ class BTMinerV3(StockFirmware):
                 # print("Пулы обновлены")
                 return True
 
-            except Exception as e:
+            except Exception:
                 # print(f"Ошибка: {e}")
                 return False
             finally:

{pyasic_umhost-0.2.3.dev16 → pyasic_umhost-0.2.4.dev2}/pyasic/miners/backends/vnish.py

@@ -14,11 +14,14 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+import asyncio
 import logging
 
 from pyasic import MinerConfig
 from pyasic.config.mining import MiningModePreset
+from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import VnishError
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.device.algorithm import AlgoHashRateType
 from pyasic.errors import APIError
 from pyasic.miners.backends.bmminer import BMMiner
@@ -32,8 +35,31 @@ from pyasic.miners.data import (
 from pyasic.miners.device.firmware import VNishFirmware
 from pyasic.web.vnish import VNishWebAPI
 
+_POOL_ALIVE_STATUSES = {"active", "working", "rejecting"}
+_HASHBOARD_ACTIVE_STATES = {"mining", "initializing"}
+_VNISH_STOPPED_STATES = {"stopped", "shutting-down", "failure"}
+
+
+def _parse_pool_url(url: str | None) -> PoolUrl | None:
+    if not url:
+        return None
+    pu = PoolUrl.from_str(url)
+    if pu is not None:
+        return pu
+    # VNish sometimes returns the URL без схемы
+    return PoolUrl.from_str(f"stratum+tcp://{url}")
+
+
 VNISH_DATA_LOC = DataLocations(
     **{
+        str(DataOptions.SERIAL_NUMBER): DataFunction(
+            "_get_serial_number",
+            [WebAPICommand("web_info", "info")],
+        ),
+        str(DataOptions.PSU_SERIAL_NUMBER): DataFunction(
+            "_get_psu_serial_number",
+            [WebAPICommand("web_factory_info", "chains/factory-info")],
+        ),
         str(DataOptions.MAC): DataFunction(
             "_get_mac",
             [WebAPICommand("web_summary", "summary")],
@@ -60,7 +86,11 @@ VNISH_DATA_LOC = DataLocations(
         ),
         str(DataOptions.HASHBOARDS): DataFunction(
             "_get_hashboards",
-            [RPCAPICommand("rpc_stats", "stats")],
+            [
+                RPCAPICommand("rpc_stats", "stats"),
+                WebAPICommand("web_summary", "summary"),
+                WebAPICommand("web_factory_info", "chains/factory-info"),
+            ],
         ),
         str(DataOptions.WATTAGE): DataFunction(
             "_get_wattage",
@@ -72,7 +102,14 @@ VNISH_DATA_LOC = DataLocations(
         ),
         str(DataOptions.FANS): DataFunction(
             "_get_fans",
-            [RPCAPICommand("rpc_stats", "stats")],
+            [
+                RPCAPICommand("rpc_stats", "stats"),
+                WebAPICommand("web_summary", "summary"),
+            ],
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light",
+            [WebAPICommand("web_status", "status")],
         ),
         str(DataOptions.UPTIME): DataFunction(
             "_get_uptime",
@@ -88,7 +125,10 @@ VNISH_DATA_LOC = DataLocations(
         ),
         str(DataOptions.POOLS): DataFunction(
             "_get_pools",
-            [RPCAPICommand("rpc_pools", "pools")],
+            [
+                RPCAPICommand("rpc_pools", "pools"),
+                WebAPICommand("web_summary", "summary"),
+            ],
         ),
         str(DataOptions.ERRORS): DataFunction(
             "_get_errors",
@@ -117,40 +157,78 @@ class VNish(VNishFirmware, BMMiner):
             miner_settings=config.as_vnish(user_suffix=user_suffix)
         )
 
-    async def restart_backend(self) -> bool:
-        data = await self.web.restart_vnish()
-        if data:
+    async def _wait_for_mining_state(
+        self,
+        *,
+        expect_stopped: bool,
+        timeout: float = 8.0,
+        interval: float = 0.5,
+    ) -> bool:
+        """Опрашивает /status и ждёт, пока miner_state перейдёт в нужный класс.
+
+        VNish обычно отвечает 200 с пустым телом на mining/{stop,resume,...} —
+        одного «успеха» от send_command для подтверждения мало, нужно
+        дождаться, что miner_state действительно перешёл в требуемый режим.
+        """
+        iterations = max(1, int(timeout / interval) + 1)
+        observed_state: str | None = None
+        for i in range(iterations):
+            if i > 0:
+                await asyncio.sleep(interval)
             try:
-                return data["success"]
-            except KeyError:
-                pass
+                status = await self.web.status()
+            except APIError:
+                status = None
+            state = status.get("miner_state") if isinstance(status, dict) else None
+            if isinstance(state, str):
+                observed_state = state
+                if (state in _VNISH_STOPPED_STATES) == expect_stopped:
+                    return True
+        logging.warning(
+            "%s: ожидалось %s состояние, последнее наблюдённое: %r",
+            self,
+            "stopped" if expect_stopped else "running",
+            observed_state,
+        )
         return False
 
+    async def restart_backend(self) -> bool:
+        try:
+            await self.web.restart_vnish()
+        except APIError as exc:
+            logging.debug("%s restart_backend: %s — проверяю состояние", self, exc)
+        # restart должен в итоге вернуть майнер в работающее состояние
+        # (через restarting/starting → mining)
+        return await self._wait_for_mining_state(
+            expect_stopped=False, timeout=15.0, interval=1.0
+        )
+
     async def stop_mining(self) -> bool:
-        data = await self.web.stop_mining()
-        if data:
-            try:
-                return data["success"]
-            except KeyError:
-                pass
-        return False
+        try:
+            await self.web.stop_mining()
+        except APIError as exc:
+            # VNish часто отвечает пустым телом — это нормально, верифицируем
+            logging.debug("%s stop_mining: %s — проверяю состояние", self, exc)
+        return await self._wait_for_mining_state(expect_stopped=True)
 
     async def resume_mining(self) -> bool:
-        data = await self.web.resume_mining()
-        if data:
-            try:
-                return data["success"]
-            except KeyError:
-                pass
-        return False
+        try:
+            await self.web.resume_mining()
+        except APIError as exc:
+            logging.debug("%s resume_mining: %s — проверяю состояние", self, exc)
+        return await self._wait_for_mining_state(expect_stopped=False)
 
     async def reboot(self) -> bool:
-        data = await self.web.reboot()
-        if data:
-            try:
-                return data["success"]
-            except KeyError:
-                pass
+        try:
+            data = await self.web.reboot()
+        except APIError as exc:
+            # /system/reboot часто рвёт соединение до отправки ответа — это норма
+            logging.debug("%s reboot: соединение оборвано: %s", self, exc)
+            return True
+        if isinstance(data, dict):
+            # ответ либо {"after": int} (по спеке), либо {"success": True} (наш фоллбэк
+            # для пустого тела). Оба варианта — успех.
+            return bool(data.get("success", True) or "after" in data)
         return False
 
     async def _get_mac(self, web_summary: dict | None = None) -> str | None:
@@ -411,3 +489,187 @@ class VNish(VNishFirmware, BMMiner):
 
     async def _get_kernel_log(self) -> str | None:
         return await self.web.get_log()
+
+    async def _get_serial_number(
+        self, web_info: dict | None = None
+    ) -> str | None:
+        if web_info is None:
+            try:
+                web_info = await self.web.info()
+            except APIError:
+                return None
+        if isinstance(web_info, dict):
+            serial = web_info.get("serial")
+            if isinstance(serial, str) and serial:
+                return serial
+        return None
+
+    async def _get_psu_serial_number(
+        self, web_factory_info: dict | None = None
+    ) -> str | None:
+        if web_factory_info is None:
+            try:
+                web_factory_info = await self.web.factory_info()
+            except APIError:
+                return None
+        if isinstance(web_factory_info, dict):
+            psu_serial = web_factory_info.get("psu_serial")
+            if isinstance(psu_serial, str) and psu_serial:
+                return psu_serial
+        return None
+
+    async def _get_fault_light(
+        self, web_status: dict | None = None
+    ) -> bool | None:
+        if web_status is None:
+            try:
+                web_status = await self.web.status()
+            except APIError:
+                return None
+        if isinstance(web_status, dict):
+            value = web_status.get("find_miner")
+            if isinstance(value, bool):
+                return value
+        return None
+
+    async def _get_pools(  # type: ignore[override]
+        self,
+        rpc_pools: dict | None = None,
+        web_summary: dict | None = None,
+    ) -> list[PoolMetrics]:
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                web_summary = None
+
+        if isinstance(web_summary, dict):
+            miner = web_summary.get("miner") or {}
+            web_pools = miner.get("pools") if isinstance(miner, dict) else None
+            if isinstance(web_pools, list) and web_pools:
+                pools: list[PoolMetrics] = []
+                for item in web_pools:
+                    if not isinstance(item, dict):
+                        continue
+                    status = item.get("status")
+                    pool_url = _parse_pool_url(item.get("url"))
+                    pools.append(
+                        PoolMetrics(
+                            url=pool_url,
+                            accepted=item.get("accepted"),
+                            rejected=item.get("rejected"),
+                            get_failures=None,
+                            remote_failures=None,
+                            active=status == "active",
+                            alive=isinstance(status, str)
+                            and status in _POOL_ALIVE_STATUSES,
+                            index=item.get("id"),
+                            user=item.get("user"),
+                        )
+                    )
+                return pools
+
+        # fallback to cgminer RPC (parent implementation)
+        return await super()._get_pools(rpc_pools=rpc_pools)
+
+    async def _get_hashboards(  # type: ignore[override]
+        self,
+        rpc_stats: dict | None = None,
+        web_summary: dict | None = None,
+        web_factory_info: dict | None = None,
+    ) -> list[HashBoard]:
+        boards = await super()._get_hashboards(rpc_stats=rpc_stats)
+        boards_by_slot: dict[int, HashBoard] = {b.slot: b for b in boards}
+
+        # enrich from web summary (chain voltage, status, hydro temps)
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                web_summary = None
+
+        if isinstance(web_summary, dict):
+            miner = web_summary.get("miner") or {}
+            chains = miner.get("chains") if isinstance(miner, dict) else None
+            if isinstance(chains, list):
+                for chain in chains:
+                    if not isinstance(chain, dict):
+                        continue
+                    slot = chain.get("id")
+                    if not isinstance(slot, int):
+                        continue
+                    board = boards_by_slot.get(slot)
+                    if board is None:
+                        board = HashBoard(
+                            slot=slot, expected_chips=self.expected_chips
+                        )
+                        boards.append(board)
+                        boards_by_slot[slot] = board
+
+                    voltage = chain.get("voltage")
+                    if isinstance(voltage, (int, float)):
+                        board.voltage = float(voltage)
+
+                    state = (chain.get("status") or {}).get("state")
+                    if isinstance(state, str):
+                        board.active = state in _HASHBOARD_ACTIVE_STATES
+                        if state != "disconnected":
+                            board.missing = False
+
+                    inlet = chain.get("inlet_water_temp")
+                    if isinstance(inlet, (int, float)):
+                        board.inlet_temp = float(inlet)
+                    outlet = chain.get("outlet_water_temp")
+                    if isinstance(outlet, (int, float)):
+                        board.outlet_temp = float(outlet)
+
+        # enrich serial numbers from factory-info
+        if web_factory_info is None:
+            try:
+                web_factory_info = await self.web.factory_info()
+            except APIError:
+                web_factory_info = None
+
+        if isinstance(web_factory_info, dict):
+            fi_chains = web_factory_info.get("chains")
+            if isinstance(fi_chains, list):
+                for chain in fi_chains:
+                    if not isinstance(chain, dict):
+                        continue
+                    slot = chain.get("id")
+                    serial = chain.get("serial")
+                    if isinstance(slot, int) and isinstance(serial, str) and serial:
+                        board = boards_by_slot.get(slot)
+                        if board is not None:
+                            board.serial_number = serial
+
+        return boards
+
+    async def _get_fans(  # type: ignore[override]
+        self,
+        rpc_stats: dict | None = None,
+        web_summary: dict | None = None,
+    ) -> list[Fan]:
+        if web_summary is None:
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                web_summary = None
+
+        if isinstance(web_summary, dict):
+            miner = web_summary.get("miner") or {}
+            cooling = miner.get("cooling") if isinstance(miner, dict) else None
+            cooling_fans = (
+                cooling.get("fans") if isinstance(cooling, dict) else None
+            )
+            if isinstance(cooling_fans, list) and cooling_fans:
+                return [
+                    Fan(
+                        speed=f.get("rpm") if isinstance(f, dict) else None,
+                        max_speed=f.get("max_rpm") if isinstance(f, dict) else None,
+                    )
+                    for f in cooling_fans
+                ]
+
+        # fallback to RPC stats via parent
+        return await super()._get_fans(rpc_stats=rpc_stats)

{pyasic_umhost-0.2.3.dev16 → pyasic_umhost-0.2.4.dev2}/pyasic/rpc/btminer.py

@@ -1211,7 +1211,23 @@ class BTMinerV3RPCAPI(BaseMinerRPCAPI):
         cmd_dict = cmd.model_dump()
         ser = json.dumps(cmd_dict).encode("utf-8")
         header = struct.pack("<I", len(ser))
-        return json.loads(await self._send_bytes(header + ser))
+        raw = await self._send_bytes(header + ser)
+        if not raw:
+            # _send_bytes отдаёт b"" если соединение оборвалось до получения
+            # ответа (RST / EOF в _read_bytes). Поднимаем APIError, чтобы
+            # вызывающие _get_* методы могли отработать штатно — иначе
+            # JSONDecodeError утекает наверх и ломает get_data().
+            raise APIError(
+                f"{self} - no data from RPC for command '{command}' "
+                f"(connection reset or EOF)"
+            )
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError as exc:
+            preview = raw[:80].decode("utf-8", errors="replace")
+            raise APIError(
+                f"{self} - bad JSON for command '{command}': {exc} (got {preview!r})"
+            ) from exc
 
     async def _send_bytes(
         self,