onvif-python 0.0.1__py3-none-any.whl

onvif/__init__.py

@@ -0,0 +1,13 @@
+# onvif/__init__.py
+
+from .client import ONVIFClient
+from .operator import ONVIFOperator, CacheMode
+from .utils import ONVIFWSDL, ONVIFOperationException
+
+__all__ = [
+    "ONVIFClient",
+    "ONVIFOperator",
+    "CacheMode",
+    "ONVIFWSDL",
+    "ONVIFOperationException",
+]

onvif/client.py

@@ -0,0 +1,485 @@
+# onvif/client.py
+
+from urllib.parse import urlparse, urlunparse
+
+from .services import (
+    Device,
+    Events,
+    PullPoint,
+    Notification,
+    Subscription,
+    Imaging,
+    Media,
+    Media2,
+    PTZ,
+    DeviceIO,
+    AccessControl,
+    AccessRules,
+    ActionEngine,
+    Analytics,
+    RuleEngine,
+    AnalyticsDevice,
+    AppManagement,
+    AuthenticationBehavior,
+    Credential,
+    Recording,
+    Replay,
+    Display,
+    DoorControl,
+    Provisioning,
+    Receiver,
+    Schedule,
+    Search,
+    Thermal,
+    Uplink,
+    AdvancedSecurity,
+    JWT,
+    Keystore,
+    TLSServer,
+    Dot1X,
+    AuthorizationServer,
+    MediaSigning,
+)
+from .operator import CacheMode
+
+
+class ONVIFClient:
+    def __init__(
+        self,
+        host,
+        port,
+        username,
+        password,
+        timeout=10,
+        cache=CacheMode.ALL,
+        use_https=False,
+        verify_ssl=True,
+    ):
+        self.common_args = {
+            "host": host,
+            "port": port,
+            "username": username,
+            "password": password,
+            "timeout": timeout,
+            "cache": cache,
+            "use_https": use_https,
+            "verify_ssl": verify_ssl,
+        }
+
+        # Device Management (Core) service is always available
+        self._devicemgmt = Device(**self.common_args)
+
+        # Retrieve device capabilities once and reuse
+        self.capabilities = self._devicemgmt.GetCapabilities(Category="All")
+
+        # Lazy init for other services
+
+        self._events = None
+        self._pullpoint = None
+        self._notification = None
+        self._subscription = None
+
+        self._imaging = None
+
+        self._media = None
+        self._media2 = None
+
+        self._ptz = None
+
+        self._deviceio = None
+
+        self._display = None
+
+        self._analytics = None
+        self._ruleengine = None
+        self._analyticsdevice = None
+
+        self._accesscontrol = None
+        self._doorcontrol = None
+
+        self._accessrules = None
+
+        self._actionengine = None
+
+        self._appmanagement = None
+
+        self._authenticationbehavior = None
+
+        self._credential = None
+
+        self._recording = None
+        self._replay = None
+
+        self._provisioning = None
+
+        self._receiver = None
+
+        self._schedule = None
+
+        self._search = None
+
+        self._thermal = None
+
+        self._uplink = None
+
+        self._security = None
+        self._jwt = None
+        self._keystore = None
+        self._tlsserver = None
+        self._dot1x = None
+        self._authorizationserver = None
+        self._mediasigning = None
+
+    def _get_xaddr(self, service_name: str, service_path: str):
+        """
+        Resolve XAddr from GetCapabilities. Fallback to default if not present.
+        """
+        svc = getattr(self.capabilities, service_name, None)
+        if svc and hasattr(svc, "XAddr") and svc.XAddr:
+            parsed = urlparse(svc.XAddr)
+
+            # Host/port from device
+            device_host = parsed.hostname
+            device_port = parsed.port
+
+            # Host/port from connection
+            connect_host = self.common_args["host"]
+            connect_port = self.common_args["port"]
+
+            # if host/port differ, rewrite XAddr to use connection values
+            if (device_host != connect_host) or (device_port != connect_port):
+                protocol = parsed.scheme
+                new_netloc = f"{connect_host}:{connect_port}"
+                rewritten = urlunparse((protocol, new_netloc, parsed.path, "", "", ""))
+                return rewritten
+
+            return svc.XAddr
+
+        # fallback (legacy style)
+        protocol = "https" if self.common_args["use_https"] else "http"
+        return f"{protocol}://{self.common_args['host']}:{self.common_args['port']}/onvif/{service_path}"
+
+    # Core (Device Management)
+
+    def devicemgmt(self):
+        return self._devicemgmt
+
+    # Core (Events)
+
+    def events(self):
+        if self._events is None:
+            self._events = Events(
+                xaddr=self._get_xaddr("Events", "Events"), **self.common_args
+            )
+        return self._events
+
+    def pullpoint(self, SubscriptionRef):
+        if self._pullpoint is None:
+            xaddr = None
+            try:
+                addr_obj = SubscriptionRef["SubscriptionReference"]["Address"]
+                if isinstance(addr_obj, dict) and "_value_1" in addr_obj:
+                    xaddr = addr_obj["_value_1"]
+                elif hasattr(addr_obj, "_value_1"):
+                    xaddr = addr_obj._value_1
+            except Exception:
+                pass
+
+            if not xaddr:
+                raise RuntimeError(
+                    "SubscriptionReference.Address missing in subscription response"
+                )
+
+            self._pullpoint = PullPoint(xaddr=xaddr, **self.common_args)
+        return self._pullpoint
+
+    def notification(self):
+        if self._notification is None:
+            self._notification = Notification(
+                xaddr=self._get_xaddr("Events", "Events"), **self.common_args
+            )
+        return self._notification
+
+    def subscription(self, SubscriptionRef):
+        if self._subscription is None:
+            xaddr = None
+            try:
+                addr_obj = SubscriptionRef["SubscriptionReference"]["Address"]
+                if isinstance(addr_obj, dict) and "_value_1" in addr_obj:
+                    xaddr = addr_obj["_value_1"]
+                elif hasattr(addr_obj, "_value_1"):
+                    xaddr = addr_obj._value_1
+            except Exception:
+                pass
+
+            if not xaddr:
+                raise RuntimeError(
+                    "SubscriptionReference.Address missing in subscription response"
+                )
+
+            self._subscription = Subscription(xaddr=xaddr, **self.common_args)
+        return self._subscription
+
+    # Imaging
+
+    def imaging(self):
+        if self._imaging is None:
+            self._imaging = Imaging(
+                xaddr=self._get_xaddr("Imaging", "Imaging"), **self.common_args
+            )
+        return self._imaging
+
+    # Media
+
+    def media(self):
+        if self._media is None:
+            self._media = Media(
+                xaddr=self._get_xaddr("Media", "Media"), **self.common_args
+            )
+        return self._media
+
+    def media2(self):
+        if self._media2 is None:
+            self._media2 = Media2(
+                xaddr=self._get_xaddr("Media2", "Media2"), **self.common_args
+            )
+        return self._media2
+
+    # PTZ
+
+    def ptz(self):
+        if self._ptz is None:
+            self._ptz = PTZ(xaddr=self._get_xaddr("PTZ", "PTZ"), **self.common_args)
+        return self._ptz
+
+    # DeviceIO
+
+    def deviceio(self):
+        if self._deviceio is None:
+            self._deviceio = DeviceIO(
+                xaddr=self._get_xaddr("DeviceIO", "DeviceIO"), **self.common_args
+            )
+        return self._deviceio
+
+    # Display
+
+    def display(self):
+        if self._display is None:
+            self._display = Display(
+                xaddr=self._get_xaddr("Display", "Display"), **self.common_args
+            )
+        return self._display
+
+    # Analytics
+
+    def analytics(self):
+        if self._analytics is None:
+            self._analytics = Analytics(
+                xaddr=self._get_xaddr("Analytics", "Analytics"), **self.common_args
+            )
+        return self._analytics
+
+    def ruleengine(self):
+        if self._ruleengine is None:
+            self._ruleengine = RuleEngine(
+                xaddr=self._get_xaddr("Analytics", "Analytics"), **self.common_args
+            )
+        return self._ruleengine
+
+    def analyticsdevice(self):
+        if self._analyticsdevice is None:
+            self._analyticsdevice = AnalyticsDevice(
+                xaddr=self._get_xaddr("AnalyticsDevice", "AnalyticsDevice"),
+                **self.common_args,
+            )
+        return self._analyticsdevice
+
+    # PACS
+
+    def accesscontrol(self):
+        if self._accesscontrol is None:
+            self._accesscontrol = AccessControl(
+                xaddr=self._get_xaddr("AccessControl", "AccessControl"),
+                **self.common_args,
+            )
+        return self._accesscontrol
+
+    def doorcontrol(self):
+        if self._doorcontrol is None:
+            self._doorcontrol = DoorControl(
+                xaddr=self._get_xaddr("DoorControl", "DoorControl"), **self.common_args
+            )
+        return self._doorcontrol
+
+    # AccessRules
+
+    def accessrules(self):
+        if self._accessrules is None:
+            self._accessrules = AccessRules(
+                xaddr=self._get_xaddr("AccessRules", "AccessRules"), **self.common_args
+            )
+        return self._accessrules
+
+    # ActionEngine
+
+    def actionengine(self):
+        if self._actionengine is None:
+            self._actionengine = ActionEngine(
+                xaddr=self._get_xaddr("ActionEngine", "ActionEngine"),
+                **self.common_args,
+            )
+        return self._actionengine
+
+    # AppManagement
+
+    def appmanagement(self):
+        if self._appmanagement is None:
+            self._appmanagement = AppManagement(
+                xaddr=self._get_xaddr("AppManagement", "AppManagement"),
+                **self.common_args,
+            )
+        return self._appmanagement
+
+    # AuthenticationBehavior
+
+    def authenticationbehavior(self):
+        if self._authenticationbehavior is None:
+            self._authenticationbehavior = AuthenticationBehavior(
+                xaddr=self._get_xaddr(
+                    "AuthenticationBehavior", "AuthenticationBehavior"
+                ),
+                **self.common_args,
+            )
+        return self._authenticationbehavior
+
+    # Credential
+
+    def credential(self):
+        if self._credential is None:
+            self._credential = Credential(
+                xaddr=self._get_xaddr("Credential", "Credential"),
+                **self.common_args,
+            )
+        return self._credential
+
+    # Recording
+
+    def recording(self):
+        if self._recording is None:
+            self._recording = Recording(
+                xaddr=self._get_xaddr("Recording", "Recording"),
+                **self.common_args,
+            )
+        return self._recording
+
+    # Replay
+
+    def replay(self):
+        if self._replay is None:
+            self._replay = Replay(
+                xaddr=self._get_xaddr("Replay", "Replay"),
+                **self.common_args,
+            )
+        return self._replay
+
+    # Provisioning
+
+    def provisioning(self):
+        if self._provisioning is None:
+            self._provisioning = Provisioning(
+                xaddr=self._get_xaddr("Provisioning", "Provisioning"),
+                **self.common_args,
+            )
+        return self._provisioning
+
+    # Receiver
+
+    def receiver(self):
+        if self._receiver is None:
+            self._receiver = Receiver(
+                xaddr=self._get_xaddr("Receiver", "Receiver"),
+                **self.common_args,
+            )
+        return self._receiver
+
+    # Schedule
+
+    def schedule(self):
+        if self._schedule is None:
+            self._schedule = Schedule(
+                xaddr=self._get_xaddr("Schedule", "Schedule"),
+                **self.common_args,
+            )
+        return self._schedule
+
+    # Search
+
+    def search(self):
+        if self._search is None:
+            self._search = Search(
+                xaddr=self._get_xaddr("Search", "Search"),
+                **self.common_args,
+            )
+        return self._search
+
+    # Thermal
+
+    def thermal(self):
+        if self._thermal is None:
+            self._thermal = Thermal(
+                xaddr=self._get_xaddr("Thermal", "Thermal"),
+                **self.common_args,
+            )
+        return self._thermal
+
+    # Uplink
+
+    def uplink(self):
+        if self._uplink is None:
+            self._uplink = Uplink(
+                xaddr=self._get_xaddr("Uplink", "Uplink"),
+                **self.common_args,
+            )
+        return self._uplink
+
+    # Security - AdvancedSecurity
+
+    def security(self):
+        if self._security is None:
+            self._security = AdvancedSecurity(
+                xaddr=self._get_xaddr("Security", "Security"),
+                **self.common_args,
+            )
+        return self._security
+
+    def jwt(self, xaddr):
+        if self._jwt is None:
+            self._jwt = JWT(xaddr=xaddr, **self.common_args)
+        return self._jwt
+
+    def keystore(self, xaddr):
+        if self._keystore is None:
+            self._keystore = Keystore(xaddr=xaddr, **self.common_args)
+        return self._keystore
+
+    def tlsserver(self, xaddr):
+        if self._tlsserver is None:
+            self._tlsserver = TLSServer(xaddr=xaddr, **self.common_args)
+        return self._tlsserver
+
+    def dot1x(self, xaddr):
+        if self._dot1x is None:
+            self._dot1x = Dot1X(xaddr=xaddr, **self.common_args)
+        return self._dot1x
+
+    def authorizationserver(self, xaddr):
+        if self._authorizationserver is None:
+            self._authorizationserver = AuthorizationServer(
+                xaddr=xaddr, **self.common_args
+            )
+        return self._authorizationserver
+
+    def mediasigning(self, xaddr):
+        if self._mediasigning is None:
+            self._mediasigning = MediaSigning(xaddr=xaddr, **self.common_args)
+        return self._mediasigning

onvif/operator.py

@@ -0,0 +1,130 @@
+# onvif/operator.py
+
+import os
+import logging
+import requests
+
+from enum import Enum
+from zeep import Settings, Transport, Client, CachingClient
+from zeep.cache import SqliteCache
+from zeep.exceptions import Fault
+from zeep.wsse.username import UsernameToken
+
+from .utils import ONVIFOperationException
+
+
+class CacheMode(Enum):
+    ALL = "all"  # CachingClient + SqliteCache →
+    # (+) Fast startup (WSDL/schema cached in memory + disk), great for multi-device and long-running apps
+    # (-) More complex, extra overhead on both disk and memory
+    # Use case: Production servers with many cameras, need stability & bandwidth savings
+
+    DB = "db"  # Client + SqliteCache →
+    # (+) Persistent disk cache, saves bandwidth (WSDL/schema not fetched every time)
+    # (-) Still parses full WSDL into memory at each startup
+    # Use case: Batch jobs / CLI tools, or low-resource environments needing long-term cache
+
+    MEM = "mem"  # CachingClient only →
+    # (+) Lightweight compared to ALL, in-memory cache only, fast during runtime
+    # (-) Cache lost on restart, WSDL will be fetched again after each restart
+    # Use case: Short-lived scripts, demos, quick debugging, no need for disk persistence
+
+    NONE = "none"  # Client only →
+    # (+) Simplest, no caching at all
+    # (-) Slow (always fetches & parses WSDL), high bandwidth usage
+    # Use case: Pure debugging, small integration testing without performance concerns
+
+
+class ONVIFOperator:
+    def __init__(
+        self,
+        wsdl_path: str,
+        host: str,
+        port: int,
+        username: str = None,
+        password: str = None,
+        timeout: int = 10,
+        binding: str = None,
+        service_path: str = None,
+        xaddr: str = None,
+        cache: CacheMode = CacheMode.ALL,  # all | db | mem | none
+        cache_path: str = None,
+        use_https: bool = False,
+        verify_ssl: bool = True,
+    ):
+        self.wsdl_path = wsdl_path
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.timeout = timeout
+
+        if xaddr:
+            self.address = xaddr
+        else:
+            protocol = "https" if use_https else "http"
+            path = service_path or "device_service"  # default fallback
+            self.address = f"{protocol}://{host}:{port}/onvif/{path}"
+
+        # Session reuse with retry strategy
+        session = requests.Session()
+        session.verify = verify_ssl
+
+        transport_kwargs = {"session": session, "timeout": timeout}
+
+        if cache in (CacheMode.DB, CacheMode.ALL):
+            if cache_path is None:
+                user_cache_dir = os.path.expanduser("~/.onvif-python")
+                os.makedirs(user_cache_dir, exist_ok=True)
+                cache_path = os.path.join(user_cache_dir, "onvif_zeep_cache.sqlite")
+
+            transport_kwargs["cache"] = SqliteCache(path=cache_path)
+
+        transport = Transport(**transport_kwargs)
+
+        # zeep settings
+        settings = Settings(strict=False, xml_huge_tree=True)
+        wsse = (
+            UsernameToken(username, password, use_digest=True)
+            if username and password
+            else None
+        )
+
+        if cache == CacheMode.ALL:
+            ClientType = CachingClient
+        elif cache == CacheMode.MEM:
+            ClientType = CachingClient
+        elif cache == CacheMode.DB:
+            ClientType = Client
+        elif cache == CacheMode.NONE:
+            ClientType = Client
+        else:
+            raise ValueError(f"Unknown cache option: {cache}")
+
+        self.client = ClientType(
+            wsdl=self.wsdl_path,
+            transport=transport,
+            settings=settings,
+            wsse=wsse,
+        )
+
+        if not binding:
+            raise ValueError("Bindings must be set according to the WSDL service")
+
+        self.service = self.client.create_service(binding, self.address)
+        logging.debug(f"ONVIFCore initialized {binding} at {self.address}")
+
+    def call(self, method: str, *args, **kwargs):
+        try:
+            func = getattr(self.service, method)
+        except AttributeError as e:
+            raise ONVIFOperationException(operation=method, original_exception=e)
+
+        try:
+            return func(*args, **kwargs)
+        except Fault as e:
+            # logging.error(f"SOAP Fault in {method}: {e}")
+            raise ONVIFOperationException(operation=method, original_exception=e)
+        except Exception as e:
+            # logging.error(f"ONVIF call error in {method}: {e}")
+            raise ONVIFOperationException(operation=method, original_exception=e)

onvif/services/__init__.py

@@ -0,0 +1,75 @@
+from .devicemgmt import Device
+from .events.events import Events
+from .events.pullpoint import PullPoint
+from .events.notification import Notification
+from .events.subscription import Subscription
+from .imaging import Imaging
+from .media import Media
+from .media2 import Media2
+from .ptz import PTZ
+from .accesscontrol import AccessControl
+from .accessrules import AccessRules
+from .actionengine import ActionEngine
+from .analytics.analytics import Analytics
+from .analytics.ruleengine import RuleEngine
+from .analyticsdevice import AnalyticsDevice
+from .appmgmt import AppManagement
+from .authenticationbehavior import AuthenticationBehavior
+from .credential import Credential
+from .deviceio import DeviceIO
+from .display import Display
+from .doorcontrol import DoorControl
+from .provisioning import Provisioning
+from .receiver import Receiver
+from .recording import Recording
+from .replay import Replay
+from .schedule import Schedule
+from .search import Search
+from .thermal import Thermal
+from .uplink import Uplink
+from .security.advancedsecurity import AdvancedSecurity
+from .security.jwt import JWT
+from .security.keystore import Keystore
+from .security.tlsserver import TLSServer
+from .security.dot1x import Dot1X
+from .security.authorizationserver import AuthorizationServer
+from .security.mediasigning import MediaSigning
+
+__all__ = [
+    "Device",
+    "Events",
+    "PullPoint",
+    "Notification",
+    "Subscription",
+    "Imaging",
+    "Media",
+    "Media2",
+    "PTZ",
+    "AccessControl",
+    "AccessRules",
+    "ActionEngine",
+    "Analytics",
+    "RuleEngine",
+    "AnalyticsDevice",
+    "AppManagement",
+    "AuthenticationBehavior",
+    "Credential",
+    "DeviceIO",
+    "Display",
+    "DoorControl",
+    "Provisioning",
+    "Receiver",
+    "Recording",
+    "Replay",
+    "Schedule",
+    "Search",
+    "Thermal",
+    "Uplink",
+    "AdvancedSecurity",
+    "JWT",
+    "Keystore",
+    "TLSServer",
+    "Dot1X",
+    "AuthorizationServer",
+    "MediaSigning",
+]