pyasic-umhost 0.2.4.dev1__tar.gz → 0.2.4.dev2__tar.gz

{pyasic_umhost-0.2.4.dev1 → pyasic_umhost-0.2.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyasic-umhost
-Version: 0.2.4.dev1
+Version: 0.2.4.dev2
 Summary: Fork of pyasic — a simplified and standardized interface for Bitcoin ASICs.
 License: Apache 2.0
 Keywords: python,asic,bitcoin,whatsminer,antminer,braiins-os,vnish,luxos

{pyasic_umhost-0.2.4.dev1 → 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.4.dev1 → 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.4.dev1 → 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,

{pyasic_umhost-0.2.4.dev1 → pyasic_umhost-0.2.4.dev2}/pyasic/web/vnish.py

@@ -92,7 +92,18 @@ class VNishWebAPI(BaseWebAPI):
                         # refresh the token, retry
                         await self.auth()
                         continue
-                    json_data = response.json()
+                    # часть VNish-эндпойнтов (mining/stop|resume|pause|start|
+                    # switch-pool, autotune/reset*, apikeys/delete, lock, notes
+                    # put/delete, logs/*/clear) отвечает 200 с пустым телом —
+                    # считаем это успехом, а не JSON-ошибкой
+                    body = (response.text or "").strip()
+                    if not body:
+                        return {"success": True}
+                    try:
+                        json_data = response.json()
+                    except json.JSONDecodeError:
+                        # 200 OK с не-JSON телом — тоже трактуем как успех
+                        return {"success": True}
                     if json_data:
                         return json_data
                     return {"success": True}
@@ -101,14 +112,6 @@ class VNishWebAPI(BaseWebAPI):
                         raise APIError(
                             f"HTTP error sending '{command}' to {self.ip}: {e}"
                         )
-                except json.JSONDecodeError as e:
-                    if attempt == retries - 1:
-                        response_text = (
-                            response.text if response.text else "empty response"
-                        )
-                        raise APIError(
-                            f"JSON decode error for '{command}' from {self.ip}: {e} - Response: {response_text}"
-                        )
                 except AttributeError as e:
                     if attempt == retries - 1:
                         raise APIError(
@@ -122,7 +125,11 @@ class VNishWebAPI(BaseWebAPI):
         data: dict[str, Any] = {k: None for k in commands}
         data["multicommand"] = True
         for command in commands:
-            data[command] = await self.send_command(command)
+            try:
+                data[command] = await self.send_command(command)
+            except APIError:
+                # одной упавшей команды не должно ронять весь батч
+                data[command] = None
         return data
 
     async def restart_vnish(self) -> dict:
@@ -180,6 +187,12 @@ class VNishWebAPI(BaseWebAPI):
     async def autotune_presets(self) -> dict:
         return await self.send_command("autotune/presets")
 
+    async def factory_info(self) -> dict:
+        return await self.send_command("chains/factory-info")
+
+    async def model(self) -> dict:
+        return await self.send_command("model")
+
     async def find_miner(self) -> dict:
         return await self.send_command("find-miner", privileged=True)
 

{pyasic_umhost-0.2.4.dev1 → pyasic_umhost-0.2.4.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyasic-umhost"
-version = "0.2.4.dev1"
+version = "0.2.4.dev2"
 description = "Fork of pyasic — a simplified and standardized interface for Bitcoin ASICs."
 authors = [{name = "UpstreamData", email = "brett@upstreamdata.ca"}]
 repository = "https://github.com/UpstreamData/pyasic"