netaudio-lib 0.0.1__tar.gz

netaudio_lib-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+*.pyc
+.eggs
+.sw*
+dist/
+__pycache__
+debug.log
+.hypothesis/

netaudio_lib-0.0.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: netaudio-lib
+Version: 0.0.1
+Summary: Python library for controlling Audinate Dante network audio devices
+Project-URL: Repository, https://github.com/chris-ritsen/network-audio-controller
+Author-email: Christopher Ritsen <chris.ritsen@gmail.com>
+License-Expression: Unlicense
+Keywords: audinate,audio,dante,network
+Requires-Python: >=3.9
+Requires-Dist: ifaddr>=0.2.0
+Requires-Dist: sqlitedict>=1.7.0
+Requires-Dist: zeroconf>=0.38.3
+Description-Content-Type: text/markdown
+
+# netaudio-lib
+
+Python library for controlling Audinate Dante network audio devices.
+
+## Installation
+
+```bash
+pip install netaudio-lib
+```
+
+## Usage
+
+```python
+from netaudio_lib import DanteBrowser
+
+browser = DanteBrowser(mdns_timeout=5)
+```

netaudio_lib-0.0.1/README.md

@@ -0,0 +1,17 @@
+# netaudio-lib
+
+Python library for controlling Audinate Dante network audio devices.
+
+## Installation
+
+```bash
+pip install netaudio-lib
+```
+
+## Usage
+
+```python
+from netaudio_lib import DanteBrowser
+
+browser = DanteBrowser(mdns_timeout=5)
+```

netaudio_lib-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "netaudio-lib"
+version = "0.0.1"
+description = "Python library for controlling Audinate Dante network audio devices"
+readme = "README.md"
+license = "Unlicense"
+requires-python = ">=3.9"
+authors = [{ name = "Christopher Ritsen", email = "chris.ritsen@gmail.com" }]
+keywords = ["audinate", "audio", "dante", "network"]
+dependencies = [
+    "zeroconf>=0.38.3",
+    "ifaddr>=0.2.0",
+    "sqlitedict>=1.7.0",
+]
+
+[project.urls]
+Repository = "https://github.com/chris-ritsen/network-audio-controller"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/netaudio_lib"]

netaudio_lib-0.0.1/src/netaudio_lib/__init__.py

@@ -0,0 +1,21 @@
+from importlib.metadata import version
+
+__version__ = version("netaudio-lib")
+
+from netaudio_lib.dante.application import DanteApplication
+from netaudio_lib.dante.browser import DanteBrowser
+from netaudio_lib.dante.channel import DanteChannel
+from netaudio_lib.dante.device import DanteDevice
+from netaudio_lib.dante.events import DanteEvent, DanteEventDispatcher, EventType
+from netaudio_lib.dante.subscription import DanteSubscription
+
+__all__ = [
+    "DanteApplication",
+    "DanteBrowser",
+    "DanteChannel",
+    "DanteDevice",
+    "DanteEvent",
+    "DanteEventDispatcher",
+    "EventType",
+    "DanteSubscription",
+]

netaudio_lib-0.0.1/src/netaudio_lib/common/app_config.py

@@ -0,0 +1,96 @@
+import sys
+
+import ifaddr
+
+DEFAULT_MDNS_TIMEOUT = 5
+DEFAULT_INTERFACE = None
+
+
+def get_available_interfaces():
+    interfaces = []
+    adapters = ifaddr.get_adapters()
+
+    for adapter in adapters:
+        for ip in adapter.ips:
+            if isinstance(ip.ip, str):
+                interfaces.append((adapter.nice_name, ip.ip, ip.network_prefix))
+
+    return sorted(interfaces)
+
+
+class AppSettings:
+    def __init__(self):
+        self._mdns_timeout: float = DEFAULT_MDNS_TIMEOUT
+        self.dump_payloads: bool = False
+        self.debug: bool = False
+        self.no_color: bool = False
+        self._interface: str = DEFAULT_INTERFACE
+        self._interface_ip: str = None
+        self.refresh: bool = False
+        self.socket_path: str = None
+
+    @property
+    def mdns_timeout(self) -> float:
+        return self._mdns_timeout
+
+    @mdns_timeout.setter
+    def mdns_timeout(self, value: float) -> None:
+        if value > 0:
+            self._mdns_timeout = value
+        else:
+            print(
+                f"Warning: mDNS timeout must be positive. Received {value}. Using default {DEFAULT_MDNS_TIMEOUT}s instead.",
+                file=sys.stderr,
+            )
+
+            self._mdns_timeout = DEFAULT_MDNS_TIMEOUT
+
+    @property
+    def interface(self) -> str:
+        return self._interface
+
+    @interface.setter
+    def interface(self, value: str) -> None:
+        self._interface = value
+        self._interface_ip = None
+
+    @property
+    def interface_ip(self) -> str:
+        if not self._interface:
+            return None
+
+        if self._interface_ip:
+            return self._interface_ip
+
+        adapters = ifaddr.get_adapters()
+
+        for adapter in adapters:
+            if adapter.nice_name == self._interface:
+                ipv4_addresses = [ip.ip for ip in adapter.ips if isinstance(ip.ip, str)]
+
+                if ipv4_addresses:
+                    self._interface_ip = ipv4_addresses[0]
+
+                    print(
+                        f"Using IPv4 address {self._interface_ip} for interface {self._interface}",
+                        file=sys.stderr,
+                    )
+
+                    return self._interface_ip
+
+                print(
+                    f"No IPv4 address found for interface {self._interface}",
+                    file=sys.stderr,
+                )
+
+                return None
+
+        print(
+            f"Warning: Could not find interface '{self._interface}'. Using default interface.",
+            file=sys.stderr,
+        )
+
+        return None
+
+
+settings = AppSettings()

netaudio_lib-0.0.1/src/netaudio_lib/common/mdns_cache.py

@@ -0,0 +1,73 @@
+import os
+import tempfile
+import time
+from typing import Any, Dict, Optional, Union
+
+from sqlitedict import SqliteDict
+
+DEFAULT_CACHE_TTL = 600
+CACHE_FILENAME = "netaudio_mdns_cache.sqlite"
+
+
+class MdnsCache:
+    def __init__(self, ttl: int = DEFAULT_CACHE_TTL, cache_dir: Optional[str] = None):
+        self.ttl = ttl
+        if cache_dir is None:
+            cache_dir = tempfile.gettempdir()
+
+        self.cache_file_path = os.path.join(cache_dir, CACHE_FILENAME)
+
+        os.makedirs(cache_dir, exist_ok=True)
+
+        self._db = SqliteDict(self.cache_file_path, autocommit=True)
+
+    def get(self, key: str) -> Optional[Dict[str, Any]]:
+        if key not in self._db:
+            return None
+
+        entry: Union[Dict[str, Any], None] = self._db.get(key)
+
+        if (
+            entry is None
+            or not isinstance(entry, dict)
+            or "last_seen" not in entry
+            or "data" not in entry
+        ):
+            self.delete(key)
+            return None
+
+        last_seen_timestamp = entry.get("last_seen", 0)
+        if not isinstance(last_seen_timestamp, (int, float)):
+            self.delete(key)
+            return None
+
+        if time.time() - last_seen_timestamp > self.ttl:
+            self.delete(key)
+            return None
+
+        return entry.get("data")
+
+    def set(self, key: str, value: Dict[str, Any]) -> None:
+        entry = {"data": value, "last_seen": time.time()}
+        self._db[key] = entry
+
+    def delete(self, key: str) -> None:
+        if key in self._db:
+            del self._db[key]
+
+    def clear(self) -> None:
+        self._db.clear()
+
+    def close(self) -> None:
+        if hasattr(self, "_db") and self._db is not None:
+            self._db.close()
+
+    def __del__(self):
+        self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False

netaudio_lib-0.0.1/src/netaudio_lib/common/socket_path.py

@@ -0,0 +1,44 @@
+import os
+import sys
+from pathlib import Path
+
+
+def get_runtime_dir() -> Path:
+    if sys.platform == "win32":
+        return Path(os.environ.get("TEMP", os.environ.get("TMP", "C:\\Temp")))
+
+    xdg = os.environ.get("XDG_RUNTIME_DIR")
+    if xdg:
+        return Path(xdg)
+
+    tmpdir = os.environ.get("TMPDIR")
+    if tmpdir:
+        return Path(tmpdir)
+
+    return Path("/tmp")
+
+
+def get_socket_dir() -> Path:
+    from netaudio_lib.common.app_config import settings as app_settings
+
+    if app_settings.socket_path:
+        return Path(app_settings.socket_path).parent
+
+    runtime_dir = get_runtime_dir()
+    socket_dir = runtime_dir / "netaudio"
+    return socket_dir
+
+
+def get_socket_path() -> Path:
+    from netaudio_lib.common.app_config import settings as app_settings
+
+    if app_settings.socket_path:
+        return Path(app_settings.socket_path)
+
+    return get_socket_dir() / "netaudio.sock"
+
+
+def ensure_socket_dir() -> Path:
+    socket_dir = get_socket_dir()
+    socket_dir.mkdir(parents=True, exist_ok=True)
+    return socket_dir

netaudio_lib-0.0.1/src/netaudio_lib/daemon/__init__.py

@@ -0,0 +1,2 @@
+from netaudio_lib.daemon.client import get_devices_from_daemon
+from netaudio_lib.daemon.server import NetaudioDaemon, run_daemon

netaudio_lib-0.0.1/src/netaudio_lib/daemon/client.py

@@ -0,0 +1,73 @@
+import asyncio
+import logging
+import pickle
+import struct
+
+from netaudio_lib.common.socket_path import get_socket_path
+from netaudio_lib.dante.device import DanteDevice
+
+logger = logging.getLogger("netaudio")
+
+
+async def get_devices_from_daemon() -> dict[str, DanteDevice] | None:
+    socket_path = get_socket_path()
+
+    if not socket_path.exists():
+        return None
+
+    try:
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_unix_connection(str(socket_path)),
+            timeout=1.0,
+        )
+
+        writer.write(b'\x00')
+        await writer.drain()
+
+        length_data = await asyncio.wait_for(reader.readexactly(4), timeout=1.0)
+        length = struct.unpack(">I", length_data)[0]
+
+        data = await asyncio.wait_for(reader.readexactly(length), timeout=2.0)
+        devices = pickle.loads(data)
+
+        writer.close()
+        await writer.wait_closed()
+
+        logger.info(f"Daemon: {len(devices)} devices")
+        return devices
+
+    except FileNotFoundError:
+        return None
+    except ConnectionRefusedError:
+        return None
+    except asyncio.TimeoutError:
+        logger.warning("Daemon connection timed out")
+        return None
+    except Exception as e:
+        logger.debug(f"Daemon connection error: {e}")
+        return None
+
+
+async def report_unresponsive_device(server_name: str) -> None:
+    socket_path = get_socket_path()
+
+    if not socket_path.exists():
+        return
+
+    try:
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_unix_connection(str(socket_path)),
+            timeout=1.0,
+        )
+
+        name_bytes = server_name.encode("utf-8")
+        writer.write(b'\x01')
+        writer.write(struct.pack(">I", len(name_bytes)))
+        writer.write(name_bytes)
+        await writer.drain()
+
+        writer.close()
+        await writer.wait_closed()
+
+    except Exception as e:
+        logger.debug(f"Failed to report dead device: {e}")