onvif-python 0.0.1__py3-none-any.whl

onvif/services/recording.py

@@ -0,0 +1,136 @@
+# onvif/services/recording.py
+
+from ..operator import ONVIFOperator
+from ..utils import ONVIFWSDL
+
+
+class Recording:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("recording")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Recording",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")
+
+    def CreateRecording(self, RecordingConfiguration):
+        return self.operator.call(
+            "CreateRecording", RecordingConfiguration=RecordingConfiguration
+        )
+
+    def DeleteRecording(self, RecordingToken):
+        return self.operator.call("DeleteRecording", RecordingToken=RecordingToken)
+
+    def GetRecordings(self):
+        return self.operator.call("GetRecordings")
+
+    def SetRecordingConfiguration(self, RecordingToken, RecordingConfiguration):
+        return self.operator.call(
+            "SetRecordingConfiguration",
+            RecordingToken=RecordingToken,
+            RecordingConfiguration=RecordingConfiguration,
+        )
+
+    def GetRecordingConfiguration(self, RecordingToken):
+        return self.operator.call(
+            "GetRecordingConfiguration", RecordingToken=RecordingToken
+        )
+
+    def GetRecordingOptions(self, RecordingToken):
+        return self.operator.call("GetRecordingOptions", RecordingToken=RecordingToken)
+
+    def CreateTrack(self, RecordingToken, TrackConfiguration):
+        return self.operator.call(
+            "CreateTrack",
+            RecordingToken=RecordingToken,
+            TrackConfiguration=TrackConfiguration,
+        )
+
+    def DeleteTrack(self, RecordingToken, TrackToken):
+        return self.operator.call(
+            "DeleteTrack", RecordingToken=RecordingToken, TrackToken=TrackToken
+        )
+
+    def GetTrackConfiguration(self, RecordingToken, TrackToken):
+        return self.operator.call(
+            "GetTrackConfiguration",
+            RecordingToken=RecordingToken,
+            TrackToken=TrackToken,
+        )
+
+    def SetTrackConfiguration(self, RecordingToken, TrackToken, TrackConfiguration):
+        return self.operator.call(
+            "SetTrackConfiguration",
+            RecordingToken=RecordingToken,
+            TrackToken=TrackToken,
+            TrackConfiguration=TrackConfiguration,
+        )
+
+    def CreateRecordingJob(self, JobConfiguration):
+        return self.operator.call(
+            "CreateRecordingJob", JobConfiguration=JobConfiguration
+        )
+
+    def DeleteRecordingJob(self, JobToken):
+        return self.operator.call("DeleteRecordingJob", JobToken=JobToken)
+
+    def GetRecordingJobs(self):
+        return self.operator.call("GetRecordingJobs")
+
+    def SetRecordingJobConfiguration(self, JobToken, JobConfiguration):
+        return self.operator.call(
+            "SetRecordingJobConfiguration",
+            JobToken=JobToken,
+            JobConfiguration=JobConfiguration,
+        )
+
+    def GetRecordingJobConfiguration(self, JobToken):
+        return self.operator.call("GetRecordingJobConfiguration", JobToken=JobToken)
+
+    def SetRecordingJobMode(self, JobToken, Mode):
+        return self.operator.call("SetRecordingJobMode", JobToken=JobToken, Mode=Mode)
+
+    def GetRecordingJobState(self, JobToken):
+        return self.operator.call("GetRecordingJobState", JobToken=JobToken)
+
+    def ExportRecordedData(
+        self,
+        SearchScope,
+        FileFormat,
+        StorageDestination,
+        StartPoint=None,
+        EndPoint=None,
+    ):
+        return self.operator.call(
+            "ExportRecordedData",
+            StartPoint=StartPoint,
+            EndPoint=EndPoint,
+            SearchScope=SearchScope,
+            FileFormat=FileFormat,
+            StorageDestination=StorageDestination,
+        )
+
+    def StopExportRecordedData(self, OperationToken):
+        return self.operator.call(
+            "StopExportRecordedData", OperationToken=OperationToken
+        )
+
+    def GetExportRecordedDataState(self, OperationToken):
+        return self.operator.call(
+            "GetExportRecordedDataState", OperationToken=OperationToken
+        )
+
+    def OverrideSegmentDuration(
+        self, TargetSegmentDuration, Expiration, RecordingConfiguration
+    ):
+        return self.operator.call(
+            "OverrideSegmentDuration",
+            TargetSegmentDuration=TargetSegmentDuration,
+            Expiration=Expiration,
+            RecordingConfiguration=RecordingConfiguration,
+        )

onvif/services/replay.py

@@ -0,0 +1,30 @@
+# onvif/services/replay.py
+
+from ..operator import ONVIFOperator
+from ..utils import ONVIFWSDL
+
+
+class Replay:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("replay")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Replay",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")
+
+    def GetReplayUri(self, StreamSetup, RecordingToken):
+        return self.operator.call(
+            "GetReplayUri", StreamSetup=StreamSetup, RecordingToken=RecordingToken
+        )
+
+    def GetReplayConfiguration(self):
+        return self.operator.call("GetReplayConfiguration")
+
+    def SetReplayConfiguration(self, Configuration):
+        return self.operator.call("SetReplayConfiguration", Configuration=Configuration)

onvif/services/schedule.py

@@ -0,0 +1,82 @@
+# onvif/services/schedule.py
+
+from ..operator import ONVIFOperator
+from ..utils import ONVIFWSDL
+
+
+class Schedule:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("schedule")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Schedule",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")
+
+    def GetScheduleState(self, Token):
+        return self.operator.call("GetScheduleState", Token=Token)
+
+    def GetScheduleInfo(self, Token):
+        return self.operator.call("GetScheduleInfo", Token=Token)
+
+    def GetScheduleInfoList(self, Limit=None, StartReference=None):
+        return self.operator.call(
+            "GetScheduleInfoList", Limit=Limit, StartReference=StartReference
+        )
+
+    def GetSchedules(self, Token):
+        return self.operator.call("GetSchedules", Token=Token)
+
+    def GetScheduleList(self, Limit=None, StartReference=None):
+        return self.operator.call(
+            "GetScheduleList", Limit=Limit, StartReference=StartReference
+        )
+
+    def CreateSchedule(self, Schedule):
+        return self.operator.call("CreateSchedule", Schedule=Schedule)
+
+    def SetSchedule(self, Schedule):
+        return self.operator.call("SetSchedule", Schedule=Schedule)
+
+    def ModifySchedule(self, Schedule):
+        return self.operator.call("ModifySchedule", Schedule=Schedule)
+
+    def DeleteSchedule(self, Token):
+        return self.operator.call("DeleteSchedule", Token=Token)
+
+    def GetSpecialDayGroupInfo(self, Token):
+        return self.operator.call("GetSpecialDayGroupInfo", Token=Token)
+
+    def GetSpecialDayGroupInfoList(self, Limit=None, StartReference=None):
+        return self.operator.call(
+            "GetSpecialDayGroupInfoList", Limit=Limit, StartReference=StartReference
+        )
+
+    def GetSpecialDayGroups(self, Token):
+        return self.operator.call("GetSpecialDayGroups", Token=Token)
+
+    def GetSpecialDayGroupList(self, Limit=None, StartReference=None):
+        return self.operator.call(
+            "GetSpecialDayGroupList", Limit=Limit, StartReference=StartReference
+        )
+
+    def CreateSpecialDayGroup(self, SpecialDayGroup):
+        return self.operator.call(
+            "CreateSpecialDayGroup", SpecialDayGroup=SpecialDayGroup
+        )
+
+    def SetSpecialDayGroup(self, SpecialDayGroup):
+        return self.operator.call("SetSpecialDayGroup", SpecialDayGroup=SpecialDayGroup)
+
+    def ModifySpecialDayGroup(self, SpecialDayGroup):
+        return self.operator.call(
+            "ModifySpecialDayGroup", SpecialDayGroup=SpecialDayGroup
+        )
+
+    def DeleteSpecialDayGroup(self, Token):
+        return self.operator.call("DeleteSpecialDayGroup", Token=Token)

onvif/services/search.py

@@ -0,0 +1,149 @@
+# onvif/services/search.py
+
+from ..operator import ONVIFOperator
+from ..utils import ONVIFWSDL
+
+
+class Search:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("search")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Search",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")
+
+    def GetRecordingSummary(self):
+        return self.operator.call("GetRecordingSummary")
+
+    def GetRecordingInformation(self, RecordingToken):
+        return self.operator.call(
+            "GetRecordingInformation", RecordingToken=RecordingToken
+        )
+
+    def GetMediaAttributes(self, Time, RecordingTokens=None):
+        return self.operator.call(
+            "GetMediaAttributes", RecordingTokens=RecordingTokens, Time=Time
+        )
+
+    def FindRecordings(self, Scope, KeepAliveTime, MaxMatches=None):
+        return self.operator.call(
+            "FindRecordings",
+            Scope=Scope,
+            MaxMatches=MaxMatches,
+            KeepAliveTime=KeepAliveTime,
+        )
+
+    def GetRecordingSearchResults(
+        self, SearchToken, MinResults=None, MaxResults=None, WaitTime=None
+    ):
+        return self.operator.call(
+            "GetRecordingSearchResults",
+            SearchToken=SearchToken,
+            MinResults=MinResults,
+            MaxResults=MaxResults,
+            WaitTime=WaitTime,
+        )
+
+    def FindEvents(
+        self,
+        StartPoint,
+        Scope,
+        SearchFilter,
+        IncludeStartState,
+        KeepAliveTime,
+        EndPoint=None,
+        MaxMatches=None,
+    ):
+        return self.operator.call(
+            "FindEvents",
+            StartPoint=StartPoint,
+            EndPoint=EndPoint,
+            Scope=Scope,
+            SearchFilter=SearchFilter,
+            IncludeStartState=IncludeStartState,
+            MaxMatches=MaxMatches,
+            KeepAliveTime=KeepAliveTime,
+        )
+
+    def GetEventSearchResults(
+        self, SearchToken, MinResults=None, MaxResults=None, WaitTime=None
+    ):
+        return self.operator.call(
+            "GetEventSearchResults",
+            SearchToken=SearchToken,
+            MinResults=MinResults,
+            MaxResults=MaxResults,
+            WaitTime=WaitTime,
+        )
+
+    def FindPTZPosition(
+        self,
+        StartPoint,
+        Scope,
+        SearchFilter,
+        KeepAliveTime,
+        EndPoint=None,
+        MaxMatches=None,
+    ):
+        return self.operator.call(
+            "FindPTZPosition",
+            StartPoint=StartPoint,
+            EndPoint=EndPoint,
+            Scope=Scope,
+            SearchFilter=SearchFilter,
+            MaxMatches=MaxMatches,
+            KeepAliveTime=KeepAliveTime,
+        )
+
+    def GetPTZPositionSearchResults(
+        self, SearchToken, MinResults=None, MaxResults=None, WaitTime=None
+    ):
+        return self.operator.call(
+            "GetPTZPositionSearchResults",
+            SearchToken=SearchToken,
+            MinResults=MinResults,
+            MaxResults=MaxResults,
+            WaitTime=WaitTime,
+        )
+
+    def GetSearchState(self, SearchToken):
+        return self.operator.call("GetSearchState", SearchToken=SearchToken)
+
+    def EndSearch(self, SearchToken):
+        return self.operator.call("EndSearch", SearchToken=SearchToken)
+
+    def FindMetadata(
+        self,
+        StartPoint,
+        Scope,
+        MetadataFilter,
+        KeepAliveTime,
+        EndPoint=None,
+        MaxMatches=None,
+    ):
+        return self.operator.call(
+            "FindMetadata",
+            StartPoint=StartPoint,
+            EndPoint=EndPoint,
+            Scope=Scope,
+            MetadataFilter=MetadataFilter,
+            MaxMatches=MaxMatches,
+            KeepAliveTime=KeepAliveTime,
+        )
+
+    def GetMetadataSearchResults(
+        self, SearchToken, MinResults=None, MaxResults=None, WaitTime=None
+    ):
+        return self.operator.call(
+            "GetMetadataSearchResults",
+            SearchToken=SearchToken,
+            MinResults=MinResults,
+            MaxResults=MaxResults,
+            WaitTime=WaitTime,
+        )

onvif/services/security/advancedsecurity.py

@@ -0,0 +1,19 @@
+# onvif/services/security/advancedsecurity.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class AdvancedSecurity:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("advancedsecurity")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            service_path="Security",  # fallback
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetServiceCapabilities(self):
+        return self.operator.call("GetServiceCapabilities")

onvif/services/security/authorizationserver.py

@@ -0,0 +1,31 @@
+# onvif/services/security/authorizationserver.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class AuthorizationServer:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("authorizationserver")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetAuthorizationServerConfigurations(self, Token=None):
+        return self.operator.call("GetAuthorizationServerConfigurations", Token=Token)
+
+    def CreateAuthorizationServerConfiguration(self, Configuration):
+        return self.operator.call(
+            "CreateAuthorizationServerConfiguration", Configuration=Configuration
+        )
+
+    def SetAuthorizationServerConfiguration(self, Configuration):
+        return self.operator.call(
+            "SetAuthorizationServerConfiguration", Configuration=Configuration
+        )
+
+    def DeleteAuthorizationServerConfiguration(self, Token):
+        return self.operator.call("DeleteAuthorizationServerConfiguration", Token=Token)

onvif/services/security/dot1x.py

@@ -0,0 +1,42 @@
+# onvif/services/security/dot1x.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class Dot1X:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("dot1x")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def AddDot1XConfiguration(self, Dot1XConfiguration):
+        return self.operator.call(
+            "AddDot1XConfiguration", Dot1XConfiguration=Dot1XConfiguration
+        )
+
+    def GetAllDot1XConfigurations(self):
+        return self.operator.call("GetAllDot1XConfigurations")
+
+    def GetDot1XConfiguration(self, Dot1XID):
+        return self.operator.call("GetDot1XConfiguration", Dot1XID=Dot1XID)
+
+    def DeleteDot1XConfiguration(self, Dot1XID):
+        return self.operator.call("DeleteDot1XConfiguration", Dot1XID=Dot1XID)
+
+    def SetNetworkInterfaceDot1XConfiguration(self, token, Dot1XID):
+        return self.operator.call(
+            "SetNetworkInterfaceDot1XConfiguration", token=token, Dot1XID=Dot1XID
+        )
+
+    def GetNetworkInterfaceDot1XConfiguration(self, token):
+        return self.operator.call("GetNetworkInterfaceDot1XConfiguration", token=token)
+
+    def DeleteNetworkInterfaceDot1XConfiguration(self, token):
+        return self.operator.call(
+            "DeleteNetworkInterfaceDot1XConfiguration", token=token
+        )

onvif/services/security/jwt.py

@@ -0,0 +1,21 @@
+# onvif/services/security/jwt.py
+
+from ...operator import ONVIFOperator
+from ...utils import ONVIFWSDL
+
+
+class JWT:
+    def __init__(self, xaddr=None, **kwargs):
+        definition = ONVIFWSDL.get_definition("jwt")
+        self.operator = ONVIFOperator(
+            definition["path"],
+            binding=f"{{{definition['namespace']}}}{definition['binding']}",
+            xaddr=xaddr,
+            **kwargs,
+        )
+
+    def GetJWTConfiguration(self):
+        return self.operator.call("GetJWTConfiguration")
+
+    def SetJWTConfiguration(self, Configuration):
+        return self.operator.call("SetJWTConfiguration", Configuration=Configuration)