sds200 0.8.2__py3-none-any.whl

sds200/__init__.py

@@ -0,0 +1,145 @@
+from .audio import AudioChunk, AudioStream, AudioTransport
+from .commands import (
+    GetChargeStatus,
+    GetFirmware,
+    GetModel,
+    GetScannerInfo,
+    GetSquelch,
+    GetStatus,
+    GetVolume,
+    SetSquelch,
+    SetVolume,
+    StartScannerInfoPush,
+)
+from .device import (
+    DEFAULT_SDS200_PATTERN,
+    DEFAULT_SDS_PATTERN,
+    ScannerDevice,
+    discover_scanners,
+)
+from .discovery import (
+    DEFAULT_DISCOVERY_WORKERS,
+    NetworkScanner,
+    discover_network_scanners,
+    local_ipv4_networks,
+)
+from .exceptions import (
+    CommandRejectedError,
+    SDS200Error,
+    SDSScannerError,
+    UnsupportedScannerFeatureError,
+    UnsupportedScannerModelError,
+)
+from .fallback import FallbackTransport, TransportCandidate
+from .models import (
+    ChargeStatus,
+    FirmwareResponse,
+    HealthSummary,
+    ModelResponse,
+    Packet,
+    RadioEvent,
+    RadioHealth,
+    ScannerInfo,
+    ScannerNode,
+    StatusResponse,
+    ValueResponse,
+)
+from .network import DEFAULT_UDP_PORT, UdpDatagramDecoder, UdpTransport
+from .profiles import (
+    TRANSPORT_PREFERENCES,
+    ConnectionProfile,
+    ProfileKind,
+    ProfileRepairResult,
+    ProfileStore,
+    TransportPreference,
+    profile_from_discovery,
+    repair_profile,
+)
+from .radio import SDS200, SDSScanner
+from .reliability import HealthHistory, HealthThresholds, ReconnectPolicy
+from .scanner import (
+    SUPPORTED_SCANNER_MODELS,
+    ScannerCapabilities,
+    ScannerModel,
+    capabilities_for_model,
+    infer_model_from_device_name,
+    normalize_model_name,
+)
+from .state import RadioState, RadioStateSnapshot, StateChange
+from .transport import (
+    ControlTransport,
+    SerialTransport,
+    TransportDiagnostic,
+)
+
+__all__ = [
+    "AudioChunk",
+    "AudioStream",
+    "AudioTransport",
+    "ChargeStatus",
+    "CommandRejectedError",
+    "ConnectionProfile",
+    "ControlTransport",
+    "DEFAULT_DISCOVERY_WORKERS",
+    "DEFAULT_SDS_PATTERN",
+    "DEFAULT_SDS200_PATTERN",
+    "DEFAULT_UDP_PORT",
+    "FallbackTransport",
+    "FirmwareResponse",
+    "GetChargeStatus",
+    "GetFirmware",
+    "GetModel",
+    "GetScannerInfo",
+    "GetSquelch",
+    "GetStatus",
+    "GetVolume",
+    "HealthHistory",
+    "HealthSummary",
+    "HealthThresholds",
+    "ModelResponse",
+    "NetworkScanner",
+    "Packet",
+    "ProfileKind",
+    "ProfileRepairResult",
+    "ProfileStore",
+    "RadioEvent",
+    "RadioHealth",
+    "RadioState",
+    "RadioStateSnapshot",
+    "ReconnectPolicy",
+    "SDS200",
+    "SDS200Error",
+    "SDSScanner",
+    "SDSScannerError",
+    "SUPPORTED_SCANNER_MODELS",
+    "ScannerCapabilities",
+    "ScannerDevice",
+    "ScannerInfo",
+    "ScannerModel",
+    "ScannerNode",
+    "SerialTransport",
+    "SetSquelch",
+    "SetVolume",
+    "StartScannerInfoPush",
+    "StateChange",
+    "StatusResponse",
+    "TRANSPORT_PREFERENCES",
+    "TransportCandidate",
+    "TransportPreference",
+    "TransportDiagnostic",
+    "UdpDatagramDecoder",
+    "UdpTransport",
+    "UnsupportedScannerFeatureError",
+    "UnsupportedScannerModelError",
+    "ValueResponse",
+    "capabilities_for_model",
+    "discover_network_scanners",
+    "discover_scanners",
+    "infer_model_from_device_name",
+    "local_ipv4_networks",
+    "normalize_model_name",
+    "profile_from_discovery",
+    "repair_profile",
+]
+
+__version__ = "0.8.2"

sds200/audio.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Protocol, Self, runtime_checkable
+
+from .events import EventBus
+
+
+@dataclass(frozen=True, slots=True)
+class AudioChunk:
+    """Opaque audio bytes received from an audio transport.
+
+    Codec and packet framing intentionally remain transport-specific until
+    a scanner audio protocol is implemented and validated against hardware.
+    """
+
+    data: bytes
+    received_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+
+
+AudioChunkHandler = Callable[[AudioChunk], None]
+
+
+@runtime_checkable
+class AudioTransport(Protocol):
+    """Lifecycle contract for future USB, RTP, or RTSP audio transports."""
+
+    @property
+    def endpoint(self) -> str: ...
+
+    @property
+    def running(self) -> bool: ...
+
+    def start(self, handler: AudioChunkHandler) -> None: ...
+
+    def stop(self) -> None: ...
+
+
+class AudioStream:
+    """Transport-independent audio event stream.
+
+    Audio is deliberately separate from :class:`sds200.SDSScanner`, so control
+    failover and protocol parsing cannot be destabilized by audio work.
+    """
+
+    def __init__(self, transport: AudioTransport) -> None:
+        self.transport = transport
+        self.events = EventBus()
+
+    @property
+    def endpoint(self) -> str:
+        return self.transport.endpoint
+
+    @property
+    def running(self) -> bool:
+        return self.transport.running
+
+    def on_chunk(self, callback: AudioChunkHandler) -> Callable[[], None]:
+        return self.events.subscribe("chunk", callback)
+
+    def start(self) -> None:
+        self.transport.start(self._receive_chunk)
+
+    def stop(self) -> None:
+        self.transport.stop()
+
+    def __enter__(self) -> Self:
+        self.start()
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.stop()
+
+    def _receive_chunk(self, chunk: AudioChunk) -> None:
+        self.events.emit("chunk", chunk)