OpenDahua 1.0.0__tar.gz

opendahua-1.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.3
+Name: OpenDahua
+Version: 1.0.0
+Summary: SDK for interacting with Dahua NVRs over their peer-to-peer protocol.
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: cryptography>=48.0.0
+Requires-Dist: xmltodict>=1.0.4
+Requires-Python: >=3.14

opendahua-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "OpenDahua"
+version = "1.0.0"
+description = "SDK for interacting with Dahua NVRs over their peer-to-peer protocol."
+requires-python = ">=3.14"
+dependencies = [
+    "aiofiles>=25.1.0",
+    "cryptography>=48.0.0",
+    "xmltodict>=1.0.4",
+]
+
+[dependency-groups]
+dev = [
+    "pytest==9.0.3"
+]
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["uv_build>=0.11.17,<0.12"]
+build-backend = "uv_build"

opendahua-1.0.0/src/opendahua/api/api_client.py

@@ -0,0 +1,5 @@
+from abc import ABC
+
+
+class ApiClient(ABC):
+    pass

opendahua-1.0.0/src/opendahua/api/api_request.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from typing import Type, TypeVar, Generic
+
+from opendahua.api.api_response import ApiResponse
+from opendahua.http.http_header import HttpHeader
+from opendahua.http.http_request import HttpRequest
+from opendahua.http.http_request_body import HttpRequestBody
+from opendahua.http.http_request_method import HttpRequestMethod
+from opendahua.object.url import Url
+
+T = TypeVar("T", bound=ApiResponse)
+
+class ApiRequest(ABC, Generic[T]):
+    @abstractmethod
+    def determine_endpoint(self) -> Url:
+        ...
+    
+    
+    @abstractmethod
+    def get_request_method(self) -> HttpRequestMethod:
+        ...
+    
+    
+    @abstractmethod
+    def determine_body_or_none(self) -> HttpRequestBody|None:
+        ...
+    
+    
+    def determine_all_header(self) -> list[HttpHeader]:
+        return []
+    
+    
+    def generate_http_request(self) -> HttpRequest:
+        return HttpRequest(
+            self.get_request_method(),
+            self.determine_endpoint(),
+            self.determine_all_header(),
+            self.determine_body_or_none(),
+        )
+
+
+    @abstractmethod
+    def get_response_class(self) -> Type[T]:
+        ...

opendahua-1.0.0/src/opendahua/api/api_response.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+
+class ApiResponse(ABC):
+    @classmethod
+    @abstractmethod
+    def parse(cls, value: dict) -> ApiResponse:
+        ...
+        

opendahua-1.0.0/src/opendahua/api_dahua/api_client_dahua.py

@@ -0,0 +1,108 @@
+from opendahua.api.api_request import T
+from opendahua.api_dahua.api_dahua_authentication_util import ApiDahuaAuthenticationUtil
+from opendahua.api_dahua.api_dahua_body_parser import ApiDahuaBodyParser
+from opendahua.api_dahua.request.api_request_dahua import ApiRequestDahua
+from opendahua.common_object.dahua_error import DahuaError
+from opendahua.common_object.dahua_error_bad_request import DahuaErrorBadRequest
+from opendahua.common_object.nonce import Nonce
+from opendahua.dahua.dahua_device import DahuaDevice
+from opendahua.http.http_request import HttpRequest
+from opendahua.http.http_response import HttpResponse
+from opendahua.http.http_status_code import HttpStatusCode
+from opendahua.ptcp.ptcp_http_client import PtcpHttpClient
+from opendahua.signaling_client import SignalingClient
+
+class ApiClientDahua:
+    # Error constants.
+    ERROR_DAHUA_API = "Received error response from Dahua API: \"{http_response}\"."
+    ERROR_ALREADY_CONNECTED = "Already connected."
+    ERROR_ALREADY_DISCONNECTED = "Already disconnected."
+    ERROR_EXPECTED_DIGEST_CHALLENGE = "Received response with status code \"{status_code}\" instead of digest authentication challenge."
+    ERROR_NOT_CONNECTED = "You have to use connect() to connect to the device before making API requests."
+
+
+    def __init__(self, device: DahuaDevice):
+        self._device: DahuaDevice = device
+        self._signaling_client: SignalingClient = SignalingClient(device)
+        self._http_client: PtcpHttpClient|None = None
+
+
+    async def connect(self) -> None:
+        if self._http_client is None:
+            ptcp_socket = await self._signaling_client.connect()
+            
+            http_client = PtcpHttpClient(ptcp_socket)
+            
+            await http_client.connect()
+            self._http_client = http_client
+        else:
+            raise DahuaError(self.ERROR_ALREADY_CONNECTED)
+    
+    
+    async def disconnect(self) -> None:
+        if self._http_client is None:
+            raise DahuaError(self.ERROR_ALREADY_DISCONNECTED)
+        else:
+            await self._http_client.disconnect()
+        
+    
+    async def send_request(self, api_request: ApiRequestDahua[T]) -> T:
+        client = await self._get_http_client()
+        
+        http_request = api_request.generate_http_request()
+        http_response = await client.send_request(http_request)
+        
+        if http_response.get_status_code() == HttpStatusCode.UNAUTHORIZED:
+            nonce = ApiDahuaAuthenticationUtil.determine_nonce_from_http_response_unauthorized(http_response)
+            realm = ApiDahuaAuthenticationUtil.determine_realm_from_http_response_unauthorized(http_response)
+
+            http_request = self._add_header_authentication(http_request, nonce, realm)
+            
+            http_response = await client.send_request(http_request)
+            
+            if self._is_http_response_success(http_response):
+                return self._parse_api_response(api_request, http_response)
+            elif http_response.get_status_code() == HttpStatusCode.BAD_REQUEST:
+                raise DahuaErrorBadRequest(self.ERROR_DAHUA_API.format(http_response=http_response))
+            else:
+                raise DahuaError(self.ERROR_DAHUA_API.format(http_response=http_response))
+        else:
+            raise DahuaError(self.ERROR_EXPECTED_DIGEST_CHALLENGE.format(status_code=http_response.get_status_code()))
+        
+    
+    async def _get_http_client(self) -> PtcpHttpClient:
+        if self._http_client is None:
+            raise DahuaError(self.ERROR_NOT_CONNECTED)
+        else:
+            return self._http_client
+        
+    
+    def _add_header_authentication(self, http_request: HttpRequest, nonce: Nonce, realm: str) -> HttpRequest:
+        header_authentication = ApiDahuaAuthenticationUtil.generate_header_authentication(
+            http_request,
+            self._device,
+            nonce,
+            realm,
+        )
+        http_request.add_header(header_authentication)
+        
+        return http_request
+
+        
+    def _is_http_response_success(self, http_response: HttpResponse) -> bool:
+        return http_response.get_status_code() in self._get_all_http_status_code_success()
+    
+        
+    @staticmethod
+    def _get_all_http_status_code_success() -> list[HttpStatusCode]:
+        return [
+            HttpStatusCode.OK,
+        ]
+    
+    
+    @staticmethod
+    def _parse_api_response(api_request: ApiRequestDahua[T], http_response: HttpResponse) -> T:
+        response_class = api_request.get_response_class()
+        response_body_dict = ApiDahuaBodyParser.determine_dict(http_response)
+
+        return response_class.parse(response_body_dict)

opendahua-1.0.0/src/opendahua/api_dahua/api_dahua_authentication_util.py

@@ -0,0 +1,129 @@
+import hashlib
+import re
+
+from opendahua.common_object.nonce import Nonce
+from opendahua.common_util.error_util import ErrorUtil
+from opendahua.dahua.dahua_device import DahuaDevice
+from opendahua.http.http_header import HttpHeader
+from opendahua.http.http_request import HttpRequest
+from opendahua.http.http_response import HttpResponse
+
+
+class ApiDahuaAuthenticationUtil:
+    # Header constants.
+    HEADER_KEY_AUTHORIZATION = "Authorization"
+    HEADER_KEY_DIGEST_AUTHENTICATION_REQUIRED = "WWW-Authenticate"
+
+    # Format constants.
+    FORMAT_HEADER_DIGEST = (
+        "Digest "
+        "username=\"{username}\", "
+        "realm=\"{realm}\", "
+        "nonce=\"{nonce}\", "
+        "uri=\"{url_request}\", "
+        "qop=\"{qop}\", "
+        "nc={number_of_time_nonce_used:08x}, "
+        "cnonce=\"{nonce_client}\", "
+        "response=\"{response}\", "
+        "opaque=\"{opaque}\""
+    )
+    FORMAT_HA1 = "{username}:{realm}:{password}"
+    FORMAT_HA2 = "{http_request_method}:{url_request}"
+    FORMAT_RESPONSE = "{ha1}:{nonce}:{number_of_time_nonce_used:08x}:{nonce_client}:{qop}:{ha2}"
+
+    # Digest constants.
+    DIGEST_QUALITY_OF_PROTECTION_AUTHENTICATION = "auth"
+    DIGEST_NUMBER_OF_TIME_NONCE_USED = 1
+
+    # Regex constants.
+    REGEX_PATTERN_NONCE = re.compile(r'nonce="([^"]*)"')
+    REGEX_PATTERN_REALM = re.compile(r'realm="([^"]*)"')
+
+    @classmethod
+    def determine_nonce_from_http_response_unauthorized(
+            cls,
+            http_response_unauthorized: HttpResponse,
+    ) -> Nonce:
+        header_digest_authentication_required = cls._get_header_digest_authentication_required(
+            http_response_unauthorized,
+        )
+        
+        match = cls.REGEX_PATTERN_NONCE.search(header_digest_authentication_required.get_header_value_string())
+        
+        return Nonce(match.group(1))
+    
+    @classmethod
+    def determine_realm_from_http_response_unauthorized(
+            cls,
+            http_response_unauthorized: HttpResponse,
+    ) -> str:
+        header_digest_authentication_required = cls._get_header_digest_authentication_required(
+            http_response_unauthorized,
+        )
+        
+        match = cls.REGEX_PATTERN_REALM.search(header_digest_authentication_required.get_header_value_string())
+        
+        return match.group(1)
+    
+    @classmethod
+    def _get_header_digest_authentication_required(cls, http_response_unauthorized: HttpResponse) -> HttpHeader:
+        header_digest_authentication_required = http_response_unauthorized.get_header_or_none(
+            cls.HEADER_KEY_DIGEST_AUTHENTICATION_REQUIRED,
+        )
+        
+        if header_digest_authentication_required is None:
+            raise ErrorUtil.create_error_unexpected_none_value(HttpHeader)
+        else:
+            return header_digest_authentication_required
+    
+    
+    @classmethod
+    def generate_header_authentication(
+            cls,
+            request: HttpRequest,
+            device: DahuaDevice,
+            nonce: Nonce,
+            realm: str,
+    ) -> HttpHeader:
+        quality_of_protection = cls.DIGEST_QUALITY_OF_PROTECTION_AUTHENTICATION
+        nonce_client = Nonce.create_random()
+        
+        ha1 = cls._hash_md5(
+            cls.FORMAT_HA1.format(username=device.get_username(), realm=realm, password=device.get_password()),
+        )
+        ha2 = cls._hash_md5(
+            cls.FORMAT_HA2.format(
+                http_request_method=request.get_method().value,
+                url_request=request.get_url().get_url_string(),
+            ),
+        )
+        
+        response = cls._hash_md5(
+            cls.FORMAT_RESPONSE.format(
+                ha1=ha1,
+                nonce=nonce.get_nonce_string(),
+                number_of_time_nonce_used=cls.DIGEST_NUMBER_OF_TIME_NONCE_USED,
+                nonce_client=nonce_client.get_nonce_string(),
+                qop=quality_of_protection,
+                ha2=ha2,
+            )
+        )
+        
+        return HttpHeader(
+            key=cls.HEADER_KEY_AUTHORIZATION,
+            value=cls.FORMAT_HEADER_DIGEST.format(
+                username=device.get_username(),
+                realm=realm,
+                nonce=nonce.get_nonce_string(),
+                url_request=request.get_url().get_url_string(),
+                qop=quality_of_protection,
+                number_of_time_nonce_used=cls.DIGEST_NUMBER_OF_TIME_NONCE_USED,
+                nonce_client=nonce_client.get_nonce_string(),
+                response=response,
+                opaque="",
+            )
+        )
+    
+    @staticmethod
+    def _hash_md5(value: str) -> str:
+        return hashlib.md5(value.encode()).hexdigest()

opendahua-1.0.0/src/opendahua/api_dahua/api_dahua_body_parser.py

@@ -0,0 +1,150 @@
+import re
+from datetime import datetime
+from typing import Any
+
+from opendahua.common_object.dahua_error import DahuaError
+from opendahua.common_util.error_util import ErrorUtil
+from opendahua.http.http_header import HttpHeader
+from opendahua.http.http_response import HttpResponse
+
+
+class ApiDahuaBodyParser:
+    # Error constants.
+    ERROR_UNEXPECTED_CONTENT_TYPE = "Unexpected content type \"{content_type}\"."
+    
+    # Separator constants.
+    SEPARATOR_LINE_BODY = "\r\n"
+    SEPARATOR_KEY_VALUE = "="
+    SEPARATOR_PART_KEY = "."
+
+    # TODO: verplaats http logica naar http response zelf
+    # Header constants.
+    HEADER_CONTENT_TYPE = "Content-type"
+    
+    # Content constants.
+    CONTENT_TYPE_TEXT_PLAIN = "text/plain"
+    CONTENT_TYPE_TEXT_PLAIN_CHARSET_UTF_8 = "text/plain;charset=utf-8"
+    CONTENT_TYPE_APPLICATION_HTTP = "application/http"
+    
+    # Field constants.
+    FIELD_DATA = "data"
+    
+    # Regex constants.
+    REGEX_PART_KEY_LIST = r"^(?P<key>[a-zA-Z]+)\[(?P<index>\d+)\]$"
+    REGEX_MATCH_GROUP_KEY = "key"
+    REGEX_MATCH_GROUP_INDEX = "index"
+    
+    # Index constants.
+    INDEX_FIRST = 0
+
+
+    @classmethod
+    def determine_dict(cls, http_response: HttpResponse) -> dict:
+        content_type_response = cls.determine_content_type_response(http_response)
+        
+        # TODO: Iets van should_use_key_value_parsing.
+        if content_type_response == cls.CONTENT_TYPE_TEXT_PLAIN or content_type_response == cls.CONTENT_TYPE_TEXT_PLAIN_CHARSET_UTF_8:
+            return cls.parse_body_key_value(http_response.get_body().get_http_response_body_string())
+        elif content_type_response == cls.CONTENT_TYPE_APPLICATION_HTTP:
+            return {cls.FIELD_DATA: http_response.get_body().get_http_response_body_bytes()}
+        else:
+            raise DahuaError(cls.ERROR_UNEXPECTED_CONTENT_TYPE.format(content_type=content_type_response))
+        
+        
+    @classmethod
+    def determine_content_type_response(cls, http_response: HttpResponse) -> str:
+        header_content_type = http_response.get_header_or_none(cls.HEADER_CONTENT_TYPE)
+        
+        if header_content_type is None:
+            raise ErrorUtil.create_error_unexpected_none_value(HttpHeader)
+        else:
+            return header_content_type.get_header_value_string()
+    
+    
+    @classmethod
+    def parse_body_key_value(cls, body_string: str) -> dict:
+        response_dict = {}
+        body_string_excluding_trailing_carriage_return = body_string.strip()
+        
+        all_line_body = body_string_excluding_trailing_carriage_return.split(cls.SEPARATOR_LINE_BODY)
+        
+        for line_body in all_line_body:
+            cls._parse_key_value(line_body, response_dict)
+        
+        return response_dict
+    
+    @classmethod
+    def _parse_key_value(cls, key_value_string: str, response_dict: dict) -> dict:
+        key_string_full, _, _ = key_value_string.partition(cls.SEPARATOR_KEY_VALUE)
+        is_key_nested = cls.SEPARATOR_PART_KEY in key_string_full
+        
+        separator = cls.SEPARATOR_PART_KEY if is_key_nested else cls.SEPARATOR_KEY_VALUE
+        key, _, remainder_string = key_value_string.partition(separator)
+        
+        match_list = re.search(cls.REGEX_PART_KEY_LIST, key)
+        
+        if match_list:
+            key_list = match_list.group(cls.REGEX_MATCH_GROUP_KEY)
+            index_list_item = int(match_list.group(cls.REGEX_MATCH_GROUP_INDEX))
+            
+            all_list_item = response_dict.setdefault(key_list, [])
+            is_list_item_existing = index_list_item < len(all_list_item)
+            
+            if is_key_nested:
+                if is_list_item_existing:
+                    list_item_dict = all_list_item[index_list_item]
+                else:
+                    list_item_dict = {}
+                    
+                list_item_dict_updated = cls._parse_key_value(remainder_string, list_item_dict)
+            else:
+                value_string = remainder_string
+                
+                list_item_dict_updated = cls._parse_value(value_string)
+            
+            if is_list_item_existing:
+                all_list_item[index_list_item] = list_item_dict_updated
+            else:
+                all_list_item.append(list_item_dict_updated)
+        
+        else:
+            if is_key_nested:
+                value_current = response_dict.get(key, {})
+                value_updated = cls._parse_key_value(remainder_string, value_current)
+            else:
+                value_string = remainder_string
+                
+                value_updated = cls._parse_value(value_string)
+            
+            response_dict[key] = value_updated
+        
+        return response_dict
+    
+
+    @classmethod
+    def _parse_value(cls, value_string: str) -> Any:
+        if value_string.isdigit():
+            return int(value_string)
+        elif cls._is_datetime_string(value_string):
+            return cls._parse_datetime_string(value_string)
+        else:
+            return value_string
+        
+    
+    @classmethod
+    def _is_datetime_string(cls, value_string: str) -> bool:
+        try:
+            cls._parse_datetime_string(value_string)
+            
+            return True
+        except ValueError:
+            return False
+    
+    
+    @classmethod
+    def _parse_datetime_string(cls, value_string: str) -> datetime:
+        try:
+            return datetime.fromisoformat(value_string)
+        except ValueError:
+            # TODO: magic number.
+            return datetime.strptime(value_string, "%Y-%m-%d %H:%M:%S")

opendahua-1.0.0/src/opendahua/api_dahua/api_dahua_util.py

@@ -0,0 +1,9 @@
+from datetime import datetime
+
+class ApiDahuaUtil:
+    # Format constants.
+    FORMAT_DATETIME_DAHUA_STRING = "%Y-%m-%dT%H:%M:%SZ"
+    
+    @classmethod
+    def determine_datetime_dahua_string(cls, datetime: datetime):
+        return datetime.strftime(cls.FORMAT_DATETIME_DAHUA_STRING)

opendahua-1.0.0/src/opendahua/api_dahua/object/api_dahua_media_file_find_result_item.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from opendahua.api_dahua.object.api_dahua_video_stream import ApiDahuaVideoStream
+
+
+@dataclass(frozen=True)
+class ApiDahuaMediaFileFindResultItem:
+    _channel: int
+    _time_start: datetime
+    _time_end: datetime
+    _path_file: Path
+    _file_type: str
+    _video_stream: ApiDahuaVideoStream
+
+    def get_channel_int(self) -> int:
+        return self._channel
+    
+    
+    def get_time_start(self) -> datetime:
+        return self._time_start
+    
+
+    def get_time_end(self) -> datetime:
+        return self._time_end
+    
+
+    def get_path_file(self) -> Path:
+        return self._path_file
+    
+    
+    def get_file_type(self) -> str:
+        return self._file_type
+
+    def get_video_stream(self) -> ApiDahuaVideoStream:
+        return self._video_stream

opendahua-1.0.0/src/opendahua/api_dahua/object/api_dahua_media_file_finder_identifier.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ApiDahuaMediaFileFinderIdentifier:
+    _media_file_identifier_int: int
+    
+    def get_media_file_identifier_int(self) -> int:
+        return self._media_file_identifier_int
+    
+    def __str__(self):
+        return str(self.get_media_file_identifier_int())
+    

opendahua-1.0.0/src/opendahua/api_dahua/object/api_dahua_video_stream.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ApiDahuaVideoStream(Enum):
+    MAIN = "Main"
+    EXTRA1 = "Extra1"
+    EXTRA2 = "Extra2"
+    EXTRA3 = "Extra3"

opendahua-1.0.0/src/opendahua/api_dahua/object/datetime_dahua.py

@@ -0,0 +1,8 @@
+from datetime import datetime
+
+class DateTimeDahua(datetime):
+    # Format constants.
+    FORMAT_DAHUA_DATETIME_STRING = "%Y-%m-%dT%H:%M:%SZ"
+    
+    def get_datetime_dahua_string(self) -> str:
+        return self.strftime(self.FORMAT_DAHUA_DATETIME_STRING)

opendahua-1.0.0/src/opendahua/api_dahua/request/api_request_dahua.py

@@ -0,0 +1,9 @@
+from typing import TypeVar, Generic
+
+from opendahua.api.api_request import ApiRequest
+from opendahua.api_dahua.response.api_response_dahua import ApiResponseDahua
+
+T = TypeVar("T", bound=ApiResponseDahua)
+
+class ApiRequestDahua(ApiRequest[T], Generic[T]):
+    pass

opendahua-1.0.0/src/opendahua/api_dahua/request/api_request_dahua_machine_name_read.py

@@ -0,0 +1,28 @@
+from typing import Type
+
+from opendahua.api.api_request import T
+from opendahua.api_dahua.request.api_request_dahua import ApiRequestDahua
+from opendahua.api_dahua.response.api_response_dahua_machine_name_read import ApiResponseDahuaMachineNameRead
+from opendahua.http.http_request_body import HttpRequestBody
+from opendahua.http.http_request_method import HttpRequestMethod
+from opendahua.object.url import Url
+
+
+class ApiRequestDahuaMachineNameRead(ApiRequestDahua[ApiResponseDahuaMachineNameRead]):
+    # Request constants.
+    REQUEST_ENDPOINT = "/cgi-bin/magicBox.cgi?action=getMachineName"
+
+    def determine_endpoint(self) -> Url:
+        return Url(self.REQUEST_ENDPOINT)
+    
+    
+    def get_request_method(self) -> HttpRequestMethod:
+        return HttpRequestMethod.GET
+    
+    
+    def determine_body_or_none(self) -> HttpRequestBody | None:
+        return None
+    
+    
+    def get_response_class(self) -> Type[T]:
+        return ApiResponseDahuaMachineNameRead

opendahua-1.0.0/src/opendahua/api_dahua/request/api_request_dahua_media_file_download.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+from typing import Type
+
+from opendahua.api.api_request import T
+from opendahua.api_dahua.request.api_request_dahua import ApiRequestDahua
+from opendahua.api_dahua.response.api_response_dahua_media_file_download import ApiResponseDahuaMediaFileDownload
+from opendahua.http.http_request_body import HttpRequestBody
+from opendahua.http.http_request_method import HttpRequestMethod
+from opendahua.object.url import Url
+
+
+class ApiRequestDahuaMediaFileDownload(ApiRequestDahua[ApiResponseDahuaMediaFileDownload]):
+    # Request constants.
+    REQUEST_ENDPOINT = "/cgi-bin/RPC_Loadfile/{path}"
+    
+    # Character constants.
+    CHARACTER_LEADING_SLASH = "/"
+
+    def __init__(self, path: Path):
+        self._path: Path = path
+    
+    
+    def determine_endpoint(self) -> Url:
+        return Url(self.REQUEST_ENDPOINT.format(path=str(self._path).strip(self.CHARACTER_LEADING_SLASH)))
+    
+    
+    def get_request_method(self) -> HttpRequestMethod:
+        return HttpRequestMethod.GET
+    
+    
+    def determine_body_or_none(self) -> HttpRequestBody | None:
+        return None
+    
+    
+    def get_response_class(self) -> Type[T]:
+        return ApiResponseDahuaMediaFileDownload