bianque 0.0.1__py3-none-any.whl

bianque/__init__.py

@@ -0,0 +1,12 @@
+"""BianQue(扁鹊) - cross-platform hardware inspection & burn-in workflow.
+
+扁鹊，战国名医，望闻问切。这工具给新机器做一次"体检"：
+屏幕、摄像头、麦克风、扬声器、键盘、鼠标、散热、电池、磁盘、内存、网络
+从头到尾查一遍，最后生成一份可存档的验机报告。
+"""
+
+from __future__ import annotations
+
+__version__ = "0.0.1"
+
+__all__ = ["__version__"]

bianque/__main__.py

@@ -0,0 +1,4 @@
+from bianque.app import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bianque/app.py

@@ -0,0 +1,31 @@
+"""Application entry point."""
+
+from __future__ import annotations
+
+import sys
+
+
+def main() -> int:
+    """Create the Qt application and show the main window."""
+    from PySide6.QtWidgets import QApplication
+
+    from bianque import __version__
+    from bianque.ui.main_window import MainWindow
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("BianQue")
+    app.setApplicationDisplayName("BianQue 扁鹊 · 验机工具")
+    app.setApplicationVersion(__version__)
+    app.setOrganizationName("cycleuser")
+
+    from bianque.ui.theme import apply_theme
+
+    apply_theme(app)
+
+    window = MainWindow()
+    window.show()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bianque/core/__init__.py

@@ -0,0 +1,27 @@
+"""BianQue core: hardware inspection logic (no UI)."""
+
+from bianque.core import (
+    audio,
+    battery,
+    disk,
+    memory,
+    models,
+    network,
+    report,
+    stress,
+    system,
+    thermal,
+)
+
+__all__ = [
+    "audio",
+    "battery",
+    "disk",
+    "memory",
+    "models",
+    "network",
+    "report",
+    "stress",
+    "system",
+    "thermal",
+]

bianque/core/audio.py

@@ -0,0 +1,93 @@
+"""Audio helpers: test-tone synthesis and device enumeration."""
+
+from __future__ import annotations
+
+import wave
+from typing import Any
+
+import numpy as np
+
+SAMPLE_RATE = 44100
+
+
+def generate_tone(
+    frequency: float = 440.0,
+    duration: float = 1.0,
+    sample_rate: int = SAMPLE_RATE,
+    channels: int = 2,
+    amplitude: float = 0.5,
+    fade: float = 0.02,
+) -> np.ndarray:
+    """Synthesize a stereo sine tone with short fade in/out to avoid clicks.
+
+    Returns a float32 array of shape ``(n_samples, channels)`` in [-1, 1].
+    """
+    n = int(sample_rate * duration)
+    t = np.arange(n) / sample_rate
+    wave_mono = amplitude * np.sin(2 * np.pi * frequency * t)
+    if fade > 0:
+        fade_n = int(sample_rate * fade)
+        if fade_n > 0 and fade_n * 2 < n:
+            env = np.ones(n, dtype=np.float64)
+            env[:fade_n] = np.linspace(0.0, 1.0, fade_n)
+            env[-fade_n:] = np.linspace(1.0, 0.0, fade_n)
+            wave_mono = wave_mono * env
+    stereo = np.stack([wave_mono] * channels, axis=1)
+    return stereo.astype(np.float32)  # type: ignore[no-any-return]
+
+
+def generate_sweep(
+    duration: float = 2.0,
+    sample_rate: int = SAMPLE_RATE,
+    channels: int = 2,
+    amplitude: float = 0.4,
+    f0: float = 100.0,
+    f1: float = 8000.0,
+) -> np.ndarray:
+    """Generate a log frequency sweep from ``f0`` to ``f1`` Hz."""
+    n = int(sample_rate * duration)
+    t = np.arange(n) / sample_rate
+    phase = 2 * np.pi * f0 * duration * (np.exp(t / duration * np.log(f1 / f0)) - 1) / np.log(f1 / f0)
+    mono = amplitude * np.sin(phase)
+    return np.stack([mono] * channels, axis=1).astype(np.float32)  # type: ignore[no-any-return]
+
+
+def _float_to_pcm16(samples: np.ndarray) -> bytes:
+    pcm = np.clip(samples, -1.0, 1.0)
+    pcm = (pcm * 32767.0).astype(np.int16)
+    return pcm.tobytes()
+
+
+def write_wav(path: str, samples: np.ndarray, sample_rate: int = SAMPLE_RATE) -> None:
+    """Write a float32 stereo sample array to a 16-bit PCM WAV file."""
+    pcm = _float_to_pcm16(samples)
+    channels = samples.shape[1] if samples.ndim > 1 else 1
+    with wave.open(path, "wb") as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(2)
+        wf.setframerate(sample_rate)
+        wf.writeframes(pcm)
+
+
+def list_audio_devices() -> dict[str, Any]:
+    """Enumerate input/output devices via sounddevice (best-effort)."""
+    result: dict[str, Any] = {"inputs": [], "outputs": [], "available": False}
+    try:
+        import sounddevice as sd  # type: ignore
+
+        devices = sd.query_devices()
+        result["available"] = True
+        for idx, dev in enumerate(devices):
+            entry = {
+                "index": idx,
+                "name": dev.get("name"),
+                "channels": max(dev.get("max_input_channels", 0), dev.get("max_output_channels", 0)),
+                "default_samplerate": dev.get("default_samplerate"),
+            }
+            if dev.get("max_input_channels", 0) > 0:
+                result["inputs"].append(entry)
+            if dev.get("max_output_channels", 0) > 0:
+                result["outputs"].append(entry)
+    except (ImportError, OSError):
+        pass
+    return result

bianque/core/battery.py

@@ -0,0 +1,101 @@
+"""Battery health probing (percent, cycle count, condition)."""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+import psutil
+
+from bianque.core.system import _run, _system_profiler_json
+
+IS_MAC = sys.platform == "darwin"
+IS_WIN = sys.platform == "win32"
+IS_LINUX = sys.platform.startswith("linux")
+
+
+def get_battery_info() -> dict[str, Any]:
+    info: dict[str, Any] = {
+        "present": False,
+        "percent": None,
+        "power_plugged": None,
+        "secsleft": None,
+        "cycle_count": None,
+        "condition": None,
+        "design_capacity": None,
+        "full_capacity": None,
+    }
+    try:
+        batt = psutil.sensors_battery()
+        if batt is not None:
+            info["present"] = True
+            info["percent"] = batt.percent
+            info["power_plugged"] = batt.power_plugged
+            info["secsleft"] = batt.secsleft
+    except (NotImplementedError, OSError):
+        pass
+
+    extra: dict[str, Any] = {}
+    if IS_MAC:
+        extra = _mac_battery()
+    elif IS_WIN:
+        extra = _win_battery()
+    elif IS_LINUX:
+        extra = _linux_battery()
+    info.update(extra)
+    return info
+
+
+def _mac_battery() -> dict[str, Any]:
+    power = _system_profiler_json("SPPowerDataType")
+    items = power.get("SPPowerDataType") or []
+    if not items:
+        return {}
+    batt = items[0]
+    return {
+        "cycle_count": batt.get("sppower_battery_cycle_count") or batt.get("cycle_count"),
+        "condition": batt.get("sppower_battery_condition") or batt.get("condition"),
+        "max_capacity_percent": batt.get("sppower_battery_max_capacity")
+        or batt.get("maximum_capacity"),
+    }
+
+
+def _win_battery() -> dict[str, Any]:
+    out, _, code = _run(
+        ["wmic", "path", "Win32_Battery", "get", "EstimatedChargeRemaining,DesignCapacity,FullChargeCapacity", "/value"],
+        timeout=20.0,
+    )
+    if code != 0:
+        return {}
+    result: dict[str, Any] = {}
+    for line in out.splitlines():
+        line = line.strip()
+        if "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        key, val = key.strip().lower(), val.strip()
+        if not val or val == "0":
+            continue
+        if key == "estimatedchargeremaining":
+            result["percent"] = int(val)
+        elif key == "designcapacity":
+            result["design_capacity"] = int(val)
+        elif key == "fullchargecapacity":
+            result["full_capacity"] = int(val)
+    return result
+
+
+def _linux_battery() -> dict[str, Any]:
+    out, _, code = _run(["upower", "-d"], timeout=15.0)
+    if code != 0:
+        return {}
+    result: dict[str, Any] = {}
+    for line in out.splitlines():
+        line = line.strip()
+        if line.startswith("energy-full-design"):
+            result["design_capacity"] = line.split(":", 1)[1].strip()
+        elif line.startswith("energy-full"):
+            result["full_capacity"] = line.split(":", 1)[1].strip()
+        elif line.startswith("capacity"):
+            result["percent"] = line.split(":", 1)[1].strip()
+    return result

bianque/core/disk.py

@@ -0,0 +1,94 @@
+"""Disk information and sequential read/write benchmark."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+import time
+from dataclasses import dataclass
+
+from bianque.core import system
+
+BLOCK_SIZE = 1024 * 1024  # 1 MiB
+
+
+@dataclass
+class DiskResult:
+    path: str
+    size_mb: float
+    write_speed_mbps: float
+    read_speed_mbps: float
+    error: str | None = None
+
+    def to_dict(self) -> dict[str, float | str | None]:
+        return {
+            "path": self.path,
+            "size_mb": self.size_mb,
+            "write_speed_mbps": self.write_speed_mbps,
+            "read_speed_mbps": self.read_speed_mbps,
+            "error": self.error,
+        }
+
+
+def get_disk_info() -> list[dict]:
+    return system.get_disk_partitions()
+
+
+def run_disk_benchmark(
+    path: str | None = None,
+    size_mb: float = 128.0,
+    block_size: int = BLOCK_SIZE,
+) -> DiskResult:
+    """Measure sequential write/read throughput on a temporary file.
+
+    The file is created under ``path`` (or the system temp dir), written once,
+    fsync'd, read back, then removed. Returns :class:`DiskResult`.
+    """
+    if path is None:
+        path = tempfile.gettempdir()
+    path = os.path.abspath(path)
+
+    try:
+        os.makedirs(path, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(prefix="bianque_bench_", dir=path)
+        os.close(fd)
+
+        total_bytes = int(size_mb * 1024 * 1024)
+        block = os.urandom(block_size)
+
+        # --- write ---
+        start = time.perf_counter()
+        with open(tmp, "wb") as fh:
+            remaining = total_bytes
+            while remaining > 0:
+                chunk = block if remaining >= block_size else block[:remaining]
+                fh.write(chunk)
+                remaining -= len(chunk)
+            fh.flush()
+            os.fsync(fh.fileno())
+        write_elapsed = time.perf_counter() - start
+
+        # --- read ---
+        start = time.perf_counter()
+        with open(tmp, "rb") as fh:
+            while fh.read(block_size):
+                pass
+        read_elapsed = time.perf_counter() - start
+
+        write_mbps = (total_bytes / 1024 / 1024) / write_elapsed if write_elapsed else 0.0
+        read_mbps = (total_bytes / 1024 / 1024) / read_elapsed if read_elapsed else 0.0
+
+        return DiskResult(
+            path=path,
+            size_mb=size_mb,
+            write_speed_mbps=round(write_mbps, 2),
+            read_speed_mbps=round(read_mbps, 2),
+        )
+    except OSError as exc:
+        return DiskResult(path=path, size_mb=size_mb, write_speed_mbps=0.0, read_speed_mbps=0.0, error=str(exc))
+    finally:
+        try:
+            if "tmp" in locals():
+                os.remove(tmp)
+        except OSError:
+            pass

bianque/core/memory.py

@@ -0,0 +1,112 @@
+"""Memory information and a write/read self-test."""
+
+from __future__ import annotations
+
+import sys
+import time
+from dataclasses import dataclass
+from typing import Any
+
+import psutil
+
+from bianque.core.system import _run, _system_profiler_json
+
+IS_MAC = sys.platform == "darwin"
+IS_WIN = sys.platform == "win32"
+
+
+@dataclass
+class MemoryTestResult:
+    size_mb: float
+    ok: bool
+    write_speed_mbps: float
+    read_speed_mbps: float
+    error: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "size_mb": self.size_mb,
+            "ok": self.ok,
+            "write_speed_mbps": self.write_speed_mbps,
+            "read_speed_mbps": self.read_speed_mbps,
+            "error": self.error,
+        }
+
+
+def get_memory_details() -> dict[str, Any]:
+    """Virtual memory plus physical DIMM details where available."""
+    vm = psutil.virtual_memory()
+    info: dict[str, Any] = {
+        "total_bytes": vm.total,
+        "available_bytes": vm.available,
+        "percent": vm.percent,
+        "dimm_count": None,
+        "dimm_speed": None,
+        "dimm_type": None,
+    }
+    if IS_MAC:
+        info.update(_mac_dimm())
+    elif IS_WIN:
+        info["dimm_speed"] = _win_dimm_speed()
+    return info
+
+
+def run_memory_self_test(size_mb: float = 256.0) -> MemoryTestResult:
+    """Allocate ``size_mb``, write a pattern, then read-verify it."""
+    size = int(size_mb * 1024 * 1024)
+    pattern = bytes((0x5A, 0xA5, 0x3C, 0xC3)) * (1024 * 1024 // 4)
+    try:
+        buf = bytearray(size)
+    except (MemoryError, OverflowError) as exc:
+        return MemoryTestResult(size_mb=size_mb, ok=False, write_speed_mbps=0.0, read_speed_mbps=0.0, error=str(exc))
+
+    start = time.perf_counter()
+    for i in range(0, size, len(pattern)):
+        buf[i : i + len(pattern)] = pattern
+    write_elapsed = time.perf_counter() - start
+
+    start = time.perf_counter()
+    ok = True
+    for i in range(0, size, len(pattern)):
+        if buf[i : i + len(pattern)] != pattern:
+            ok = False
+            break
+    read_elapsed = time.perf_counter() - start
+
+    write_mbps = (size / 1024 / 1024) / write_elapsed if write_elapsed else 0.0
+    read_mbps = (size / 1024 / 1024) / read_elapsed if read_elapsed else 0.0
+    return MemoryTestResult(
+        size_mb=size_mb,
+        ok=ok,
+        write_speed_mbps=round(write_mbps, 2),
+        read_speed_mbps=round(read_mbps, 2),
+    )
+
+
+def _mac_dimm() -> dict[str, Any]:
+    mem = _system_profiler_json("SPMemoryDataType")
+    items = mem.get("SPMemoryDataType") or []
+    if not items:
+        return {}
+    i0 = items[0]
+    return {
+        "dimm_count": i0.get("dimm_number") or i0.get("dimm_manufacturer"),
+        "dimm_speed": i0.get("dimm_speed"),
+        "dimm_type": i0.get("dimm_type"),
+    }
+
+
+def _win_dimm_speed() -> Any:
+    out, _, code = _run(
+        ["wmic", "memorychip", "get", "Speed,Capacity,Manufacturer", "/value"],
+        timeout=20.0,
+    )
+    if code != 0:
+        return None
+    speeds = []
+    for line in out.splitlines():
+        if "=" in line:
+            key, _, val = line.partition("=")
+            if key.strip().lower() == "speed" and val.strip().isdigit():
+                speeds.append(val.strip())
+    return speeds[0] if speeds else None

bianque/core/models.py

@@ -0,0 +1,89 @@
+"""Shared data models for BianQue checks and reports."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+
+class Status:
+    """Unified check result status."""
+
+    PASS = "pass"
+    FAIL = "fail"
+    UNKNOWN = "unknown"
+    SKIPPED = "skipped"
+
+    @classmethod
+    def all(cls) -> list[str]:
+        return [cls.PASS, cls.FAIL, cls.UNKNOWN, cls.SKIPPED]
+
+
+@dataclass
+class CheckResult:
+    """A single check item result.
+
+    Attributes:
+        key: Stable identifier such as ``screen.dead_pixel``.
+        name: Human-readable display name.
+        status: One of :class:`Status`.
+        message: Human-readable outcome summary.
+        data: Structured payload (metrics, raw numbers).
+        timestamp: Epoch seconds when the check was produced.
+    """
+
+    key: str
+    name: str
+    status: str = Status.UNKNOWN
+    message: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: float = field(default_factory=time.time)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "key": self.key,
+            "name": self.name,
+            "status": self.status,
+            "message": self.message,
+            "data": self.data,
+            "timestamp": self.timestamp,
+        }
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> CheckResult:
+        return cls(
+            key=str(raw.get("key", "")),
+            name=str(raw.get("name", "")),
+            status=str(raw.get("status", Status.UNKNOWN)),
+            message=str(raw.get("message", "")),
+            data=dict(raw.get("data", {})),
+            timestamp=float(raw.get("timestamp", time.time())),
+        )
+
+
+@dataclass
+class Report:
+    """Aggregated inspection report."""
+
+    results: list[CheckResult] = field(default_factory=list)
+    generated_at: float = field(default_factory=time.time)
+    host: str = ""
+    platform: str = ""
+
+    def add(self, result: CheckResult) -> None:
+        self.results.append(result)
+
+    def count_by_status(self) -> dict[str, int]:
+        counts: dict[str, int] = dict.fromkeys(Status.all(), 0)
+        for r in self.results:
+            counts[r.status] = counts.get(r.status, 0) + 1
+        return counts
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "generated_at": self.generated_at,
+            "host": self.host,
+            "platform": self.platform,
+            "results": [r.to_dict() for r in self.results],
+        }

bianque/core/network.py

@@ -0,0 +1,126 @@
+"""Network interface information and ICMP latency probing."""
+
+from __future__ import annotations
+
+import re
+import socket
+import sys
+from dataclasses import dataclass, field
+from typing import Any
+
+import psutil
+
+from bianque.core.system import _run
+
+IS_WIN = sys.platform == "win32"
+
+_TIME_RE = re.compile(r"time[=<]\s*([0-9.]+)\s*ms", re.IGNORECASE)
+_TRANSMITTED_RE = re.compile(r"(\d+)\s+packets?\s+transmitted", re.IGNORECASE)
+_RECEIVED_RE = re.compile(r"(\d+)\s+packets?\s+received", re.IGNORECASE)
+_LOSS_RE = re.compile(r"([0-9.]+)%\s+packet\s+loss", re.IGNORECASE)
+_ROUNDTRIP_RE = re.compile(
+    r"round-trip[^=]*=\s*([0-9.]+)/([0-9.]+)/([0-9.]+)", re.IGNORECASE
+)
+
+
+@dataclass
+class PingResult:
+    host: str
+    transmitted: int = 0
+    received: int = 0
+    loss_percent: float = 0.0
+    min_ms: float | None = None
+    avg_ms: float | None = None
+    max_ms: float | None = None
+    error: str | None = None
+    times_ms: list[float] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "host": self.host,
+            "transmitted": self.transmitted,
+            "received": self.received,
+            "loss_percent": self.loss_percent,
+            "min_ms": self.min_ms,
+            "avg_ms": self.avg_ms,
+            "max_ms": self.max_ms,
+            "error": self.error,
+        }
+
+
+def get_network_info() -> dict[str, Any]:
+    addrs = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()
+    counters = psutil.net_io_counters(pernic=True)
+
+    interfaces = []
+    for name, addr_list in addrs.items():
+        ips = [a.address for a in addr_list if a.family == socket.AF_INET]
+        macs = [
+            a.address
+            for a in addr_list
+            if a.family not in (socket.AF_INET, socket.AF_INET6)
+        ]
+        stat = stats.get(name)
+        counter = counters.get(name)
+        interfaces.append(
+            {
+                "name": name,
+                "ips": ips,
+                "mac": macs[0] if macs else None,
+                "up": stat.isup if stat else None,
+                "speed_mbps": stat.speed if stat else None,
+                "bytes_sent": counter.bytes_sent if counter else None,
+                "bytes_recv": counter.bytes_recv if counter else None,
+            }
+        )
+    return {"interfaces": interfaces}
+
+
+def ping(host: str = "8.8.8.8", count: int = 4, timeout: float = 10.0) -> PingResult:
+    """Ping ``host`` ``count`` times and parse round-trip latency."""
+    if IS_WIN:
+        cmd = ["ping", "-n", str(count), "-w", str(int(timeout * 1000)), host]
+    else:
+        cmd = ["ping", "-c", str(count), "-W", str(int(timeout)), host]
+    out, err, code = _run(cmd, timeout=timeout + 5.0)
+    result = PingResult(host=host)
+
+    if code != 0:
+        result.error = (err or out).strip()[:200] or "ping failed"
+        return result
+
+    times = [float(m) for m in _TIME_RE.findall(out)]
+    result.times_ms = times
+
+    transmitted = _extract_int(_TRANSMITTED_RE, out, count)
+    received = _extract_int(_RECEIVED_RE, out, len(times))
+    loss = _extract_float(_LOSS_RE, out, None)
+    result.transmitted = transmitted
+    result.received = received
+    if loss is not None:
+        result.loss_percent = loss
+    elif transmitted > 0:
+        result.loss_percent = round((transmitted - received) / transmitted * 100, 1)
+
+    if times:
+        result.min_ms = round(min(times), 2)
+        result.avg_ms = round(sum(times) / len(times), 2)
+        result.max_ms = round(max(times), 2)
+    else:
+        m = _ROUNDTRIP_RE.search(out)
+        if m:
+            result.min_ms = round(float(m.group(1)), 2)
+            result.avg_ms = round(float(m.group(2)), 2)
+            result.max_ms = round(float(m.group(3)), 2)
+    return result
+
+
+def _extract_int(pattern: re.Pattern[str], text: str, default: int) -> int:
+    m = pattern.search(text)
+    return int(m.group(1)) if m else default
+
+
+def _extract_float(pattern: re.Pattern[str], text: str, default: float | None) -> float | None:
+    m = pattern.search(text)
+    return float(m.group(1)) if m else default