onvif-mcp-core 0.2.7__tar.gz

onvif_mcp_core-0.2.7/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: onvif-mcp-core
+Version: 0.2.7
+Summary: Shared camera operations for the ONVIF MCP servers
+Requires-Dist: libonvif==4.0.24
+Requires-Dist: mcp>=1.0.0
+Requires-Python: >=3.10
+Project-URL: Bug Reports, https://github.com/sr99622/onvif-mcp/issues
+Project-URL: Homepage, https://github.com/sr99622/onvif-mcp

onvif_mcp_core-0.2.7/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "onvif-mcp-core"
+version = "0.2.7"
+description = "Shared camera operations for the ONVIF MCP servers"
+requires-python = ">=3.10"
+dependencies = [
+    "libonvif==4.0.24",
+    "mcp>=1.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.0,<0.9.0"]
+build-backend = "uv_build"
+
+[project.urls]  
+"Homepage" = "https://github.com/sr99622/onvif-mcp"
+"Bug Reports" = "https://github.com/sr99622/onvif-mcp/issues"

onvif_mcp_core-0.2.7/src/onvif_mcp_core/__init__.py

@@ -0,0 +1,46 @@
+"""Shared functionality for the ONVIF MCP server transports."""
+
+from .credentials import CameraCredentials, get_camera_credentials
+from .audio import set_camera_audio_encoding, set_camera_audio_sample_rate
+from .camera_queries import get_adapters, get_camera, get_cameras
+from .device import change_camera_hostname, reboot_camera, sync_camera_time
+from .streaming import get_snapshot, get_web_player_url
+from .tools import (
+    register_audio_configuration_tools,
+    register_camera_query_tools,
+    register_device_management_tools,
+    register_ptz_tools,
+    register_streaming_tools,
+    register_video_configuration_tools,
+)
+from .video import (
+    set_camera_video_bitrate,
+    set_camera_video_frame_rate,
+    set_camera_video_gov_length,
+    set_camera_video_resolution,
+)
+
+__all__ = [
+    "CameraCredentials",
+    "get_camera_credentials",
+    "get_camera",
+    "get_cameras",
+    "get_adapters",
+    "get_web_player_url",
+    "get_snapshot",
+    "change_camera_hostname",
+    "reboot_camera",
+    "sync_camera_time",
+    "register_audio_configuration_tools",
+    "register_camera_query_tools",
+    "register_device_management_tools",
+    "register_ptz_tools",
+    "register_streaming_tools",
+    "register_video_configuration_tools",
+    "set_camera_audio_encoding",
+    "set_camera_audio_sample_rate",
+    "set_camera_video_bitrate",
+    "set_camera_video_frame_rate",
+    "set_camera_video_gov_length",
+    "set_camera_video_resolution",
+]

onvif_mcp_core-0.2.7/src/onvif_mcp_core/audio.py

@@ -0,0 +1,103 @@
+"""Shared audio encoder configuration operations."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from libonvif.devices.camera import (
+    get_camera_by_ip,
+    set_audio_encoder_configuration,
+)
+
+from .credentials import get_camera_credentials
+
+logger = logging.getLogger(__name__)
+
+
+async def _set_audio_encoder_value(
+    ip_address: str,
+    profile_token: str,
+    value: Any,
+    *,
+    setting_name: str,
+    apply_value: Callable[[Any, Any], None],
+) -> str:
+    try:
+        credentials = get_camera_credentials()
+        camera = get_camera_by_ip(
+            ip_address,
+            credentials.username,
+            credentials.password,
+        )
+    except Exception as ex:
+        logger.error("Failed to query camera at %s: %s", ip_address, ex)
+        return f"Failed to query camera at {ip_address}: {ex}"
+
+    try:
+        camera.errors = None
+        for profile in camera.profiles:
+            if profile.token == profile_token:
+                apply_value(profile.audio_encoder, value)
+                set_audio_encoder_configuration(camera, profile.audio_encoder)
+                if camera.errors:
+                    raise Exception(f"Camera returned errors: {camera.errors}")
+                return (
+                    f"Successfully set {setting_name} to {value} for camera "
+                    f"at {camera.xaddr}, profile {profile_token}."
+                )
+
+        return f"Profile {profile_token} not found on camera at {camera.xaddr}."
+    except Exception as ex:
+        logger.error(
+            "Failed to set %s for camera at %s: %s",
+            setting_name,
+            camera.xaddr,
+            ex,
+        )
+        return f"Failed to set {setting_name} for camera at {camera.xaddr}: {ex}"
+
+
+async def set_camera_audio_encoding(
+    ip_address: str,
+    profile_token: str,
+    encoding: str,
+) -> str:
+    """
+    Set the audio encoding for one media profile on a camera.
+
+    The encoding must be one of the codecs offered by the camera for the
+    selected profile, such as ``AAC`` or ``G711``.
+    """
+    return await _set_audio_encoder_value(
+        ip_address,
+        profile_token,
+        encoding,
+        setting_name="audio encoding",
+        apply_value=lambda encoder, value: setattr(encoder, "encoding", value),
+    )
+
+
+async def set_camera_audio_sample_rate(
+    ip_address: str,
+    profile_token: str,
+    sample_rate: int,
+) -> str:
+    """
+    Set the audio sample rate for one media profile on a camera.
+
+    Some cameras couple sample rate and bitrate. Re-query the camera after
+    changing this value to confirm the settings actually retained.
+    """
+    return await _set_audio_encoder_value(
+        ip_address,
+        profile_token,
+        sample_rate,
+        setting_name="audio sample rate",
+        apply_value=lambda encoder, value: setattr(
+            encoder,
+            "sample_rate",
+            value,
+        ),
+    )

onvif_mcp_core-0.2.7/src/onvif_mcp_core/camera_queries.py

@@ -0,0 +1,226 @@
+"""Transport-independent camera retrieval and discovery."""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from libonvif.devices.camera import Camera, discover, get_camera_by_ip
+from libonvif.utils.adapters import find_adapters
+from libonvif.utils.serialization import to_dict
+
+from .credentials import get_camera_credentials
+from .streaming import build_web_player_url, build_web_snapshot_url
+
+logger = logging.getLogger(__name__)
+
+
+def _get_camera_credentials(camera: Camera) -> None:
+    credentials = get_camera_credentials()
+    camera.username = credentials.username
+    camera.password = credentials.password
+
+
+def _on_error(xaddr: str, ex: Exception) -> None:
+    logger.debug("Camera discovery error at %s: %s", xaddr, ex)
+
+
+def _camera_filled(camera: Camera) -> None:
+    logger.debug(
+        "Camera filled: %s : %s",
+        camera.hostname,
+        camera.device_information.serial_number,
+    )
+
+
+async def get_camera(ip_address: str) -> str:
+    """Get the full state of a camera at the specified IP address."""
+    credentials = get_camera_credentials()
+    camera = get_camera_by_ip(
+        ip_address,
+        credentials.username,
+        credentials.password,
+    )
+    return camera.to_json()
+
+
+def _camera_summary(
+    camera: Camera,
+) -> dict[str, Any]:
+    data = to_dict(camera)
+    dev = data.get("device_information") or {}
+    hostname_obj = data.get("hostname") or {}
+    xaddr = data.get("xaddr") or ""
+    ip_addr = xaddr.split("://", 1)[1].split("/", 1)[0] if "://" in xaddr else ""
+    serial_number = dev.get("serial_number") or ""
+
+    profiles = []
+    for profile in data.get("profiles") or []:
+        video_encoder = profile.get("video_encoder") or {}
+        rate_control = video_encoder.get("rate_control") or {}
+        audio_encoder = profile.get("audio_encoder") or {}
+        token = profile.get("token") or ""
+        profiles.append(
+            {
+                "token": token,
+                "name": profile.get("name") or "",
+                "video_encoder": {
+                    "encoding": video_encoder.get("encoding") or "",
+                    "resolution": video_encoder.get("resolution") or "",
+                    "frame_rate_limit": rate_control.get("frame_rate_limit") or 0,
+                    "bitrate_limit": rate_control.get("bitrate_limit") or 0,
+                    "gov_length": video_encoder.get("gov_length") or 0,
+                },
+                "audio_encoder": {
+                    "encoding": audio_encoder.get("encoding") or "",
+                    "sample_rate": audio_encoder.get("sample_rate") or 0,
+                },
+                "stream_uri": profile.get("stream_uri") or "",
+                "snapshot_uri": profile.get("snapshot_uri") or "",
+                "web_player_url": build_web_player_url(serial_number, token),
+                "web_snapshot_url": build_web_snapshot_url(serial_number, token),
+            }
+        )
+
+    ptz = data.get("ptz") or {}
+    presets = [
+        {"token": preset.get("token") or "", "name": preset.get("name") or ""}
+        for preset in ptz.get("presets") or []
+    ]
+
+    tours = []
+    for tour in ptz.get("tours") or []:
+        tour_status = tour.get("status") or {}
+        tours.append(
+            {
+                "token": tour.get("token") or "",
+                "name": tour.get("name") or "",
+                "status": tour_status.get("state") or "",
+                "spot_count": len(tour.get("spots") or []),
+            }
+        )
+
+    ptz_status = ptz.get("status") or {}
+    capabilities = data.get("capabilities") or {}
+    ptz_capabilities = capabilities.get("ptz") or {}
+    event_properties = data.get("event_properties") or {}
+
+    return {
+        "hostname": hostname_obj.get("name") or data.get("name") or "",
+        "ip_address": ip_addr,
+        "manufacturer": dev.get("manufacturer") or "",
+        "model": dev.get("model") or "",
+        "firmware_version": dev.get("firmware_version") or "",
+        "serial_number": dev.get("serial_number") or "",
+        "profiles": profiles,
+        "ptz_presets": presets,
+        "ptz_tours": tours,
+        "ptz_status": {
+            "pan_tilt": ptz_status.get("pan_tilt_status") or "",
+            "zoom": ptz_status.get("zoom_status") or "",
+        },
+        "ptz_xaddr": ptz_capabilities.get("xaddr") or "",
+        "event_topics": event_properties.get("topic_set") or [],
+        "time_offset": int(data.get("time_offset") or 0),
+    }
+
+
+async def get_adapters() -> str:
+    """Return a list of available active network adapters.
+
+    Returns:
+        A delimited string containing the IP address of each active adapter,
+        one per line, separated by "\n--\n".
+    """
+    adapter_ips = find_adapters()
+    if not adapter_ips:
+        return ""
+
+    return "\n--\n".join(adapter_ips)
+
+
+async def get_cameras() -> str:
+    """Discover cameras and return lightweight, delimited JSON summaries."""
+    # Get all adapter IPs
+    adapter_ips = find_adapters()
+    if adapter_ips:
+        logger.debug("Host IP addresses: %s", adapter_ips)
+
+    # Discover cameras on each adapter and merge results
+    all_cameras = []
+    seen_ips = set()
+
+    for adapter_ip in adapter_ips:
+        logger.debug("Discovering cameras on adapter %s", adapter_ip)
+        cameras = discover(
+            adapter_ip,
+            _get_camera_credentials,
+            on_error=_on_error,
+            camera_filled=_camera_filled,
+            use_threads=True,
+        )
+
+        for camera in cameras:
+            # Get camera IP for deduplication
+            xaddr = getattr(camera, "xaddr", None) or ""
+            ip_addr = xaddr.split("://", 1)[1].split("/", 1)[0] if "://" in xaddr else ""
+
+            # Skip if we've already seen this camera
+            if ip_addr in seen_ips:
+                logger.debug("Skipping duplicate camera %s (already discovered)", ip_addr)
+                continue
+
+            seen_ips.add(ip_addr)
+            all_cameras.append(camera)
+
+    logger.debug("Discovered %d camera(s) total", len(all_cameras))
+
+    summaries = []
+    for camera in all_cameras:
+        try:
+            summaries.append(json.dumps(_camera_summary(camera)))
+        except Exception as ex:
+            logger.error(
+                "Failed to serialize camera at %s: %s",
+                getattr(camera, "xaddr", "?"),
+                ex,
+            )
+
+    return "\n--\n".join(summaries)
+
+
+async def get_cameras_by_adapter(adapter_ip: str) -> str:
+    """Discover cameras on a specific adapter subnet and return lightweight summaries.
+
+    Args:
+        adapter_ip: The IP address of the adapter to discover cameras on.
+
+    Returns:
+        A delimited string containing a summary dict for each camera found on
+        the specified adapter subnet. Each camera's summary is separated by a line
+        containing `--`.
+    """
+    logger.debug("Discovering cameras on adapter %s", adapter_ip)
+    cameras = discover(
+        adapter_ip,
+        _get_camera_credentials,
+        on_error=_on_error,
+        camera_filled=_camera_filled,
+        use_threads=True,
+    )
+
+    summaries = []
+    for camera in cameras:
+        try:
+            summaries.append(json.dumps(_camera_summary(camera)))
+        except Exception as ex:
+            logger.error(
+                "Failed to serialize camera at %s: %s",
+                getattr(camera, "xaddr", "?"),
+                ex,
+            )
+
+    return "\n--\n".join(summaries)

onvif_mcp_core-0.2.7/src/onvif_mcp_core/credentials.py

@@ -0,0 +1,24 @@
+"""Shared camera credential access for both MCP transports."""
+
+import os
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class CameraCredentials:
+    """Camera login values; omit the password from diagnostic representations."""
+
+    username: str
+    password: str = field(repr=False)
+
+
+def get_camera_credentials() -> CameraCredentials:
+    """Read the current environment, preserving empty defaults and whitespace.
+
+    Credential acquisition is centralized here so callers do not depend on the
+    source. Values are not cached; this preserves the existing lookup behavior.
+    """
+    return CameraCredentials(
+        username=os.environ.get("CAMERA_USERNAME", ""),
+        password=os.environ.get("CAMERA_PASSWORD", ""),
+    )

onvif_mcp_core-0.2.7/src/onvif_mcp_core/device.py

@@ -0,0 +1,98 @@
+"""Shared camera device-management operations."""
+
+from __future__ import annotations
+
+import logging
+
+from libonvif.devices.camera import (
+    get_camera_by_ip,
+    get_local_date_and_time,
+    get_time_offset,
+    reboot,
+    set_hostname,
+    set_system_date_and_time,
+)
+
+from .credentials import get_camera_credentials
+
+logger = logging.getLogger(__name__)
+
+
+def _query_camera(ip_address: str):
+    credentials = get_camera_credentials()
+    return get_camera_by_ip(
+        ip_address,
+        credentials.username,
+        credentials.password,
+    )
+
+
+def _raise_camera_errors(camera) -> None:
+    if camera.errors:
+        raise Exception(f"Camera returned errors: {camera.errors}")
+
+
+async def change_camera_hostname(ip_address: str, new_hostname: str) -> str:
+    """Change a camera's hostname by IP address."""
+    try:
+        camera = _query_camera(ip_address)
+    except Exception as ex:
+        logger.error("Failed to query camera at %s: %s", ip_address, ex)
+        return f"Failed to query camera at {ip_address}: {ex}"
+
+    try:
+        camera.hostname.name = new_hostname
+        camera.errors = None
+        set_hostname(camera)
+        _raise_camera_errors(camera)
+        return (
+            f"Successfully changed hostname of camera at {camera.xaddr} "
+            f"to {new_hostname}."
+        )
+    except Exception as ex:
+        logger.error(
+            "Failed to change hostname for camera at %s: %s",
+            camera.xaddr,
+            ex,
+        )
+        return f"Failed to change hostname for camera at {camera.xaddr}: {ex}"
+
+
+async def sync_camera_time(ip_address: str) -> str:
+    """Synchronize a camera's clock with this machine's local time."""
+    try:
+        camera = _query_camera(ip_address)
+    except Exception as ex:
+        logger.error("Failed to query camera at %s: %s", ip_address, ex)
+        return f"Failed to query camera at {ip_address}: {ex}"
+
+    try:
+        camera.errors = None
+        set_system_date_and_time(camera, get_local_date_and_time())
+        _raise_camera_errors(camera)
+        get_time_offset(camera)
+        return (
+            f"Successfully synchronized time for camera at {camera.xaddr}. "
+            f"time_offset is now {camera.time_offset} seconds."
+        )
+    except Exception as ex:
+        logger.error("Failed to sync time for camera at %s: %s", camera.xaddr, ex)
+        return f"Failed to sync time for camera at {camera.xaddr}: {ex}"
+
+
+async def reboot_camera(ip_address: str) -> str:
+    """Request that a camera reboot through ONVIF SystemReboot."""
+    try:
+        camera = _query_camera(ip_address)
+    except Exception as ex:
+        logger.error("Failed to query camera at %s: %s", ip_address, ex)
+        return f"Failed to query camera at {ip_address}: {ex}"
+
+    try:
+        camera.errors = None
+        reboot(camera)
+        _raise_camera_errors(camera)
+        return f"Successfully requested reboot for camera at {camera.xaddr}."
+    except Exception as ex:
+        logger.error("Failed to reboot camera at %s: %s", camera.xaddr, ex)
+        return f"Failed to reboot camera at {camera.xaddr}: {ex}"