onvif-python 0.0.1__py3-none-any.whl

onvif/services/security/keystore.py

@@ -0,0 +1,208 @@
+# onvif/services/security/keystore.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class Keystore:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("keystore")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def CreateRSAKeyPair(self, KeyLength, Alias=None):
+        return self.operator.call("CreateRSAKeyPair", KeyLength=KeyLength, Alias=Alias)
+
+    def CreateECCKeyPair(self, EllipticCurve, Alias=None):
+        return self.operator.call(
+            "CreateECCKeyPair", EllipticCurve=EllipticCurve, Alias=Alias
+        )
+
+    def UploadKeyPairInPKCS8(
+        self,
+        KeyPair,
+        Alias=None,
+        EncryptionPassphraseID=None,
+        EncryptionPassphrase=None,
+    ):
+        return self.operator.call(
+            "UploadKeyPairInPKCS8",
+            KeyPair=KeyPair,
+            Alias=Alias,
+            EncryptionPassphraseID=EncryptionPassphraseID,
+            EncryptionPassphrase=EncryptionPassphrase,
+        )
+
+    def UploadCertificateWithPrivateKeyInPKCS12(
+        self,
+        CertWithPrivateKey,
+        CertificationPathAlias=None,
+        KeyAlias=None,
+        IgnoreAdditionalCertificates=None,
+        IntegrityPassphraseID=None,
+        EncryptionPassphraseID=None,
+        Passphrase=None,
+    ):
+        return self.operator.call(
+            "UploadCertificateWithPrivateKeyInPKCS12",
+            CertWithPrivateKey=CertWithPrivateKey,
+            CertificationPathAlias=CertificationPathAlias,
+            KeyAlias=KeyAlias,
+            IgnoreAdditionalCertificates=IgnoreAdditionalCertificates,
+            IntegrityPassphraseID=IntegrityPassphraseID,
+            EncryptionPassphraseID=EncryptionPassphraseID,
+            Passphrase=Passphrase,
+        )
+
+    def GetKeyStatus(self, KeyID):
+        return self.operator.call("GetKeyStatus", KeyID=KeyID)
+
+    def GetPrivateKeyStatus(self, KeyID):
+        return self.operator.call("GetPrivateKeyStatus", KeyID=KeyID)
+
+    def GetAllKeys(self):
+        return self.operator.call("GetAllKeys")
+
+    def DeleteKey(self, KeyID):
+        return self.operator.call("DeleteKey", KeyID=KeyID)
+
+    def CreatePKCS10CSR(self, Subject, KeyID, SignatureAlgorithm, CSRAttribute=None):
+        return self.operator.call(
+            "DeleteKey",
+            Subject=Subject,
+            KeyID=KeyID,
+            CSRAttribute=CSRAttribute,
+            SignatureAlgorithm=SignatureAlgorithm,
+        )
+
+    def CreateSelfSignedCertificate(
+        self,
+        Subject,
+        KeyID,
+        SignatureAlgorithm,
+        X509Version=None,
+        Alias=None,
+        notValidBefore=None,
+        notValidAfter=None,
+        Extension=None,
+    ):
+        return self.operator.call(
+            "CreateSelfSignedCertificate",
+            X509Version=X509Version,
+            Subject=Subject,
+            KeyID=KeyID,
+            Alias=Alias,
+            notValidBefore=notValidBefore,
+            notValidAfter=notValidAfter,
+            SignatureAlgorithm=SignatureAlgorithm,
+            Extension=Extension,
+        )
+
+    def UploadCertificate(
+        self, Certificate, Alias=None, KeyAlias=None, PrivateKeyRequired=None
+    ):
+        return self.operator.call(
+            "UploadCertificate",
+            Certificate=Certificate,
+            Alias=Alias,
+            KeyAlias=KeyAlias,
+            PrivateKeyRequired=PrivateKeyRequired,
+        )
+
+    def GetCertificate(self, CertificateID):
+        return self.operator.call("GetCertificate", CertificateID=CertificateID)
+
+    def GetAllCertificates(self):
+        return self.operator.call("GetAllCertificates")
+
+    def DeleteCertificate(self, CertificateID):
+        return self.operator.call("DeleteCertificate", CertificateID=CertificateID)
+
+    def CreateCertificationPath(self, CertificateIDs, Alias=None):
+        return self.operator.call(
+            "CreateCertificationPath", CertificateIDs=CertificateIDs, Alias=Alias
+        )
+
+    def GetCertificationPath(self, CertificationPathID):
+        return self.operator.call(
+            "GetCertificationPath", CertificationPathID=CertificationPathID
+        )
+
+    def GetAllCertificationPaths(self):
+        return self.operator.call("GetAllCertificationPaths")
+
+    def SetCertificationPath(self, CertificationPathID, CertificationPath):
+        return self.operator.call(
+            "SetCertificationPath",
+            CertificationPathID=CertificationPathID,
+            CertificationPath=CertificationPath,
+        )
+
+    def DeleteCertificationPath(self, CertificationPathID):
+        return self.operator.call(
+            "DeleteCertificationPath", CertificationPathID=CertificationPathID
+        )
+
+    def UploadPassphrase(self, Passphrase, PassphraseAlias=None):
+        return self.operator.call(
+            "UploadPassphrase", Passphrase=Passphrase, PassphraseAlias=PassphraseAlias
+        )
+
+    def GetAllPassphrases(self):
+        return self.operator.call("GetAllPassphrases")
+
+    def DeletePassphrase(self, PassphraseID):
+        return self.operator.call("DeletePassphrase", PassphraseID=PassphraseID)
+
+    def UploadCRL(self, Crl, Alias=None, anyParameters=None):
+        return self.operator.call(
+            "UploadCRL", Crl=Crl, Alias=Alias, anyParameters=anyParameters
+        )
+
+    def GetCRL(self, CrlID):
+        return self.operator.call("GetCRL", CrlID=CrlID)
+
+    def GetAllCRLs(self):
+        return self.operator.call("GetAllCRLs")
+
+    def DeleteCRL(self, CrlID):
+        return self.operator.call("DeleteCRL", CrlID=CrlID)
+
+    def CreateCertPathValidationPolicy(
+        self, Parameters, TrustAnchor, Alias=None, anyParameters=None
+    ):
+        return self.operator.call(
+            "CreateCertPathValidationPolicy",
+            Alias=Alias,
+            Parameters=Parameters,
+            TrustAnchor=TrustAnchor,
+            anyParameters=anyParameters,
+        )
+
+    def GetCertPathValidationPolicy(self, CertPathValidationPolicyID):
+        return self.operator.call(
+            "GetCertPathValidationPolicy",
+            CertPathValidationPolicyID=CertPathValidationPolicyID,
+        )
+
+    def GetAllCertPathValidationPolicies(self):
+        return self.operator.call("GetAllCertPathValidationPolicies")
+
+    def SetCertPathValidationPolicy(
+        self, CertPathValidationPolicy, CertPathValidationPolicyID=None
+    ):
+        return self.operator.call(
+            "SetCertPathValidationPolicy",
+            CertPathValidationPolicyID=CertPathValidationPolicyID,
+            CertPathValidationPolicy=CertPathValidationPolicy,
+        )
+
+    def DeleteCertPathValidationPolicy(self, CertPathValidationPolicyID):
+        return self.operator.call(
+            "DeleteCertPathValidationPolicy",
+            CertPathValidationPolicyID=CertPathValidationPolicyID,
+        )

onvif/services/security/mediasigning.py

@@ -0,0 +1,30 @@
+# onvif/services/security/mediasigning.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class MediaSigning:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("mediasigning")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def AddMediaSigningCertificateAssignment(self, CertificationPathID):
+        return self.operator.call(
+            "AddMediaSigningCertificateAssignment",
+            CertificationPathID=CertificationPathID,
+        )
+
+    def RemoveMediaSigningCertificateAssignment(self, CertificationPathID):
+        return self.operator.call(
+            "RemoveMediaSigningCertificateAssignment",
+            CertificationPathID=CertificationPathID,
+        )
+
+    def GetAssignedMediaSigningCertificates(self):
+        return self.operator.call("GetAssignedMediaSigningCertificates")

onvif/services/security/tlsserver.py

@@ -0,0 +1,82 @@
+# onvif/services/security/tlsserver.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class TLSServer:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("tlsserver")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def AddServerCertificateAssignment(self, CertificationPathID):
+        return self.operator.call(
+            "AddServerCertificateAssignment", CertificationPathID=CertificationPathID
+        )
+
+    def RemoveServerCertificateAssignment(self, CertificationPathID):
+        return self.operator.call(
+            "RemoveServerCertificateAssignment", CertificationPathID=CertificationPathID
+        )
+
+    def ReplaceServerCertificateAssignment(
+        self, OldCertificationPathID, NewCertificationPathID
+    ):
+        return self.operator.call(
+            "ReplaceServerCertificateAssignment",
+            OldCertificationPathID=OldCertificationPathID,
+            NewCertificationPathID=NewCertificationPathID,
+        )
+
+    def GetAssignedServerCertificates(self):
+        return self.operator.call("GetAssignedServerCertificates")
+
+    def SetEnabledTLSVersions(self, Versions):
+        return self.operator.call("SetEnabledTLSVersions", Versions=Versions)
+
+    def GetEnabledTLSVersions(self):
+        return self.operator.call("GetEnabledTLSVersions")
+
+    def SetClientAuthenticationRequired(self, clientAuthenticationRequired):
+        return self.operator.call(
+            "SetClientAuthenticationRequired",
+            clientAuthenticationRequired=clientAuthenticationRequired,
+        )
+
+    def GetClientAuthenticationRequired(self):
+        return self.operator.call("GetClientAuthenticationRequired")
+
+    def SetCnMapsToUser(self, cnMapsToUser):
+        return self.operator.call("SetCnMapsToUsername", cnMapsToUser=cnMapsToUser)
+
+    def GetCnMapsToUser(self):
+        return self.operator.call("GetCnMapsToUser")
+
+    def AddCertPathValidationPolicyAssignment(self, CertPathValidationPolicyID):
+        return self.operator.call(
+            "AddCertPathValidationPolicyAssignment",
+            CertPathValidationPolicyID=CertPathValidationPolicyID,
+        )
+
+    def RemoveCertPathValidationPolicyAssignment(self, CertPathValidationPolicyID):
+        return self.operator.call(
+            "RemoveCertPathValidationPolicyAssignment",
+            CertPathValidationPolicyID=CertPathValidationPolicyID,
+        )
+
+    def ReplaceCertPathValidationPolicyAssignment(
+        self, OldCertPathValidationPolicyID, NewCertPathValidationPolicyID
+    ):
+        return self.operator.call(
+            "ReplaceCertPathValidationPolicyAssignment",
+            OldCertPathValidationPolicyID=OldCertPathValidationPolicyID,
+            NewCertPathValidationPolicyID=NewCertPathValidationPolicyID,
+        )
+
+    def GetAssignedCertPathValidationPolicies(self):
+        return self.operator.call("GetAssignedCertPathValidationPolicies")

onvif/services/thermal.py

@@ -0,0 +1,54 @@
+# onvif/services/thermal.py
+
+from ..operator import ONVIFOperator
+from ..utils import ONVIFWSDL
+
+
+class Thermal:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("thermal")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Thermal",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")
+
+    def GetConfigurationOptions(self, VideoSourceToken):
+        return self.operator.call(
+            "GetConfigurationOptions", VideoSourceToken=VideoSourceToken
+        )
+
+    def GetConfiguration(self, VideoSourceToken):
+        return self.operator.call("GetConfiguration", VideoSourceToken=VideoSourceToken)
+
+    def GetConfigurations(self):
+        return self.operator.call("GetConfigurations")
+
+    def SetConfiguration(self, VideoSourceToken, Configuration):
+        return self.operator.call(
+            "SetConfiguration",
+            VideoSourceToken=VideoSourceToken,
+            Configuration=Configuration,
+        )
+
+    def GetRadiometryConfigurationOptions(self, VideoSourceToken):
+        return self.operator.call(
+            "GetRadiometryConfigurationOptions", VideoSourceToken=VideoSourceToken
+        )
+
+    def GetRadiometryConfiguration(self, VideoSourceToken):
+        return self.operator.call(
+            "GetRadiometryConfiguration", VideoSourceToken=VideoSourceToken
+        )
+
+    def SetRadiometryConfiguration(self, VideoSourceToken, Configuration):
+        return self.operator.call(
+            "SetRadiometryConfiguration",
+            VideoSourceToken=VideoSourceToken,
+            Configuration=Configuration,
+        )

onvif/services/uplink.py

@@ -0,0 +1,28 @@
+# onvif/services/uplink.py
+
+from ..operator import ONVIFOperator
+from ..utils import ONVIFWSDL
+
+
+class Uplink:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("uplink")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Uplink",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")
+
+    def GetUplinks(self):
+        return self.operator.call("GetUplinks")
+
+    def SetUplink(self, Configuration):
+        return self.operator.call("SetUplink", Configuration=Configuration)
+
+    def DeleteUplink(self, RemoteAddress):
+        return self.operator.call("SetUplink", RemoteAddress=RemoteAddress)

onvif/utils/__init__.py

@@ -0,0 +1,4 @@
+from .wsdl import ONVIFWSDL
+from .exceptions import ONVIFOperationException
+
+__all__ = ["ONVIFWSDL", "ONVIFOperationException"]

onvif/utils/exceptions.py

@@ -0,0 +1,33 @@
+# onvif/utils/exceptions.py
+
+"""
+(1) SOAP Errors
+(2) Transport/Protocol Errors
+(3) Application Errors
+"""
+
+from zeep.exceptions import Fault
+import requests
+
+
+class ONVIFOperationException(Exception):
+    def __init__(self, operation, original_exception):
+        self.operation = operation
+        self.original_exception = original_exception
+
+        if isinstance(original_exception, Fault):
+            # SOAP-level error
+            category = "SOAP Error"
+            code = getattr(original_exception, "faultcode", None)
+            detail = getattr(original_exception, "detail", None)
+            msg = f"{category}: code={code}, msg={str(original_exception)}, detail={detail}"
+        elif isinstance(original_exception, requests.exceptions.RequestException):
+            # Transport/Protocol error
+            category = "Protocol Error"
+            msg = f"{category}: {str(original_exception)}"
+        else:
+            # Application or generic error
+            category = "Application Error"
+            msg = f"{category}: {str(original_exception)}"
+
+        super().__init__(f"ONVIF operation '{operation}' failed: {msg}")