pypetkitapi 1.9.2__py3-none-any.whl → 1.9.4__py3-none-any.whl

pypetkitapi/const.py

@@ -35,6 +35,8 @@ K3 = "k3"
 PET = "pet"
 
 DEVICES_LITTER_BOX = [T3, T4, T5, T6]
+LITTER_WITH_CAMERA = [T5, T6]
+LITTER_NO_CAMERA = [T3, T4]
 DEVICES_FEEDER = [FEEDER, FEEDER_MINI, D3, D4, D4S, D4H, D4SH]
 DEVICES_WATER_FOUNTAIN = [W5, CTW3]
 DEVICES_PURIFIER = [K2]
@@ -68,12 +70,10 @@ class Header(StrEnum):
     ACCEPT = "*/*"
     ACCEPT_LANG = "en-US;q=1, it-US;q=0.9"
     ENCODING = "gzip, deflate"
-    API_VERSION = "11.3.1"
+    API_VERSION = "11.4.0"
     CONTENT_TYPE = "application/x-www-form-urlencoded"
     AGENT = "okhttp/3.12.11"
     CLIENT = f"{Client.PLATFORM_TYPE}({Client.OS_VERSION};{Client.MODEL_NAME})"
-    TIMEZONE = "1.0"
-    TIMEZONE_ID = "Europe/Paris"  # TODO: Make this dynamic
     LOCALE = "en-US"
     IMG_VERSION = "1.0"
     HOUR = "24"
@@ -85,17 +85,28 @@ CLIENT_NFO = {
     "osVersion": Client.OS_VERSION.value,
     "platform": Client.PLATFORM_TYPE.value,
     "source": Client.SOURCE.value,
-    "timezone": Header.TIMEZONE.value,  # TODO: Make this dynamic
-    "timezoneId": Header.TIMEZONE_ID.value,
     "version": Header.API_VERSION.value,
 }
 
 LOGIN_DATA = {
-    "client": str(CLIENT_NFO),
-    "oldVersion": Header.API_VERSION,
+    "oldVersion": Header.API_VERSION.value,
 }
 
 
+class MediaType(StrEnum):
+    """Record Type constants"""
+
+    VIDEO = "avi"
+    IMAGE = "jpg"
+
+
+class VideoType(StrEnum):
+    """Record Type constants"""
+
+    HIGHLIGHT = "highlight"
+    PLAYBACK = "playback"
+
+
 class RecordType(StrEnum):
     """Record Type constants"""
 
@@ -103,9 +114,16 @@ class RecordType(StrEnum):
     FEED = "feed"
     MOVE = "move"
     PET = "pet"
+    TOILETING = "toileting"
 
 
-RecordTypeLST = [RecordType.EAT, RecordType.FEED, RecordType.MOVE, RecordType.PET]
+RecordTypeLST = [
+    RecordType.EAT,
+    RecordType.FEED,
+    RecordType.MOVE,
+    RecordType.PET,
+    RecordType.TOILETING,
+]
 
 
 class PetkitEndpoint(StrEnum):
@@ -124,6 +142,7 @@ class PetkitEndpoint(StrEnum):
     GET_DEVICE_RECORD = "getDeviceRecord"
     GET_DEVICE_RECORD_RELEASE = "getDeviceRecordRelease"
     UPDATE_SETTING = "updateSettings"
+    UPDATE_SETTING_FEEDER_MINI = "update"
 
     # Bluetooth
     BLE_AS_RELAY = "ble/ownSupportBleDevices"
@@ -143,25 +162,30 @@ class PetkitEndpoint(StrEnum):
     GET_PET_OUT_GRAPH = "getPetOutGraph"
 
     # Video features
+    GET_M3U8 = "getM3u8"
     CLOUD_VIDEO = "cloud/video"
     GET_DOWNLOAD_M3U8 = "getDownloadM3u8"
-    GET_M3U8 = "getM3u8"
 
     # Feeders
     REPLENISHED_FOOD = "added"
     FRESH_ELEMENT_CALIBRATION = "food_reset"
     FRESH_ELEMENT_CANCEL_FEED = "cancel_realtime_feed"
-    DESICCANT_RESET = "desiccantReset"
-    MINI_DESICCANT_RESET = "feedermini/desiccant_reset"
-    FRESH_ELEMENT_DESICCANT_RESET = "feeder/desiccant_reset"
+    DESICCANT_RESET_OLD = "desiccant_reset"
+    DESICCANT_RESET_NEW = "desiccantReset"
     CALL_PET = "callPet"
     CANCEL_FEED = "cancelRealtimeFeed"
-    MANUAL_FEED_MINI = "feedermini/save_dailyfeed"
-    MANUAL_FEED_FRESH_ELEMENT = "feeder/save_dailyfeed"
-    MANUAL_FEED_DUAL = "saveDailyFeed"
+    MANUAL_FEED_OLD = "save_dailyfeed"  # For Feeder/FeederMini
+    MANUAL_FEED_NEW = "saveDailyFeed"  # For all other feeders
     DAILY_FEED_AND_EAT = "dailyFeedAndEat"  # D3
     FEED_STATISTIC = "feedStatistic"  # D4
     DAILY_FEED = "dailyFeeds"  # D4S
     REMOVE_DAILY_FEED = "removeDailyFeed"
     RESTORE_DAILY_FEED = "restoreDailyFeed"
     SAVE_FEED = "saveFeed"  # For Feeding plan
+
+    # Schedule
+    SCHEDULE = "schedule/schedules"
+    SCHEDULE_SAVE = "schedule/save"
+    SCHEDULE_REMOVE = "schedule/remove"
+    SCHEDULE_COMPLETE = "schedule/complete"
+    SCHEDULE_HISTORY = "schedule/userHistorySchedules"

pypetkitapi/exceptions.py

@@ -11,6 +11,10 @@ class PetkitTimeoutError(PypetkitError):
     """Class for PyPetkit timeout exceptions."""
 
 
+class PetkitSessionError(PypetkitError):
+    """Class for PyPetkit connection exceptions."""
+
+
 class PetkitSessionExpiredError(PypetkitError):
     """Class for PyPetkit connection exceptions."""
 
@@ -18,6 +22,11 @@ class PetkitSessionExpiredError(PypetkitError):
 class PetkitAuthenticationUnregisteredEmailError(PypetkitError):
     """Exception raised when the email is not registered with Petkit."""
 
+    def __init__(self, region: str):
+        """Initialize the exception."""
+        self.message = "The email you provided is not registered on Petkit's servers. Please check your email, or you are using the correct region."
+        super().__init__(self.message)
+
 
 class PetkitRegionalServerNotFoundError(PypetkitError):
     """Exception raised when the specified region server is not found."""

pypetkitapi/feeder_container.py

@@ -49,7 +49,7 @@ class CameraMultiNew(BaseModel):
 
     enable: int | None = None
     rpt: str | None = None
-    time: list[tuple[int, int]] | None = None
+    time: list[list[int]] | None = None
 
 
 class SettingsFeeder(BaseModel):
@@ -85,9 +85,7 @@ class SettingsFeeder(BaseModel):
     highlight: int | None = None
     light_config: int | None = Field(None, alias="lightConfig")
     light_mode: int | None = Field(None, alias="lightMode")
-    light_multi_range: list[tuple[int, int]] | None = Field(
-        None, alias="lightMultiRange"
-    )
+    light_multi_range: list[list[int]] | None = Field(None, alias="lightMultiRange")
     live_encrypt: int | None = Field(None, alias="liveEncrypt")
     low_battery_notify: int | None = Field(None, alias="lowBatteryNotify")
     manual_lock: int | None = Field(None, alias="manualLock")
@@ -112,7 +110,7 @@ class SettingsFeeder(BaseModel):
     time_display: int | None = Field(None, alias="timeDisplay")
     tone_config: int | None = Field(None, alias="toneConfig")
     tone_mode: int | None = Field(None, alias="toneMode")
-    tone_multi_range: list[tuple[int, int]] | None = Field(None, alias="toneMultiRange")
+    tone_multi_range: list[list[int]] | None = Field(None, alias="toneMultiRange")
     upload: int | None = None
     volume: int | None = None
 
@@ -315,8 +313,9 @@ class Feeder(BaseModel):
     bt_mac: str | None = Field(None, alias="btMac")
     cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")
     created_at: str | None = Field(None, alias="createdAt")
+    desc: str | None = None  # D3
     device_records: FeederRecord | None = None
-    firmware: float
+    firmware: str
     firmware_details: list[FirmwareDetail] | None = Field(None, alias="firmwareDetails")
     hardware: int
     id: int

pypetkitapi/litter_container.py

@@ -9,10 +9,9 @@ from pypetkitapi.const import (
     DEVICE_DATA,
     DEVICE_RECORDS,
     DEVICE_STATS,
+    LITTER_NO_CAMERA,
+    LITTER_WITH_CAMERA,
     T3,
-    T4,
-    T5,
-    T6,
     PetkitEndpoint,
 )
 from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
@@ -240,9 +239,9 @@ class LitterRecord(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        if device_type in [T3, T4]:
+        if device_type in LITTER_NO_CAMERA:
             return PetkitEndpoint.GET_DEVICE_RECORD
-        if device_type in [T5, T6]:
+        if device_type in LITTER_WITH_CAMERA:
             return PetkitEndpoint.GET_DEVICE_RECORD_RELEASE
         raise ValueError(f"Invalid device type: {device_type}")
 
@@ -255,11 +254,11 @@ class LitterRecord(BaseModel):
     ) -> dict:
         """Generate query parameters including request_date."""
         device_type = device.device_type
-        if device_type in [T3, T4]:
+        if device_type in LITTER_NO_CAMERA:
             request_date = request_date or datetime.now().strftime("%Y%m%d")
             key = "day" if device_type == T3 else "date"
             return {key: int(request_date), "deviceId": device.device_id}
-        if device_type in [T5, T6]:
+        if device_type in LITTER_WITH_CAMERA:
             return {
                 "timestamp": int(datetime.now().timestamp()),
                 "deviceId": device.device_id,
@@ -407,7 +406,7 @@ class K3Device(BaseModel):
 
 class Litter(BaseModel):
     """Dataclass for Litter Data.
-    Supported devices = T3, T4, T6
+    Supported devices = T3, T4, T5, T6
     """
 
     data_type: ClassVar[str] = DEVICE_DATA

pypetkitapi/media.py

@@ -0,0 +1,423 @@
+"""Module to manage media files from PetKit devices."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime
+import logging
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from aiofiles import open as aio_open
+import aiohttp
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+
+from pypetkitapi import Feeder, Litter, PetKitClient, RecordType
+from pypetkitapi.const import D4H, D4SH, T5, T6, RecordTypeLST
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class MediaFile:
+    """Dataclass MediaFile.
+    Represents a media file from a PetKit device.
+    """
+
+    event_id: str
+    event_type: RecordType
+    device_id: int
+    user_id: str
+    image: str | None
+    video: str | None
+    filepath: str
+    aes_key: str
+    timestamp: int
+    is_available: bool = False
+
+
+class MediaManager:
+    """Class to manage media files from PetKit devices."""
+
+    async def get_all_media_files(
+        self, devices: list[Feeder | Litter]
+    ) -> list[MediaFile]:
+        """Get all media files from all devices and return a list of MediaFile."""
+        media_files: list[MediaFile] = []
+
+        for device in devices:
+            if isinstance(device, Feeder):
+                if device.device_nfo and device.device_nfo.device_type in [D4SH, D4H]:
+                    media_files.extend(self._process_feeder(device))
+                else:
+                    _LOGGER.debug(
+                        "Feeder %s does not support media file extraction",
+                        device.name,
+                    )
+            elif isinstance(device, Litter):
+                if device.device_nfo and device.device_nfo.device_type in [T5, T6]:
+                    media_files.extend(self._process_litter(device))
+                else:
+                    _LOGGER.debug(
+                        "Litter %s does not support media file extraction",
+                        device.name,
+                    )
+
+        return media_files
+
+    def _process_feeder(self, feeder: Feeder) -> list[MediaFile]:
+        """Process media files for a Feeder device."""
+        media_files: list[MediaFile] = []
+        records = feeder.device_records
+
+        device_id = (
+            feeder.device_nfo.device_id
+            if feeder.device_nfo and feeder.device_nfo.device_type
+            else None
+        )
+        if device_id is None:
+            raise ValueError("Missing device ID for feeder")
+
+        if not records:
+            return media_files
+
+        for record_type in RecordTypeLST:
+            record_list = getattr(records, record_type, [])
+            for record in record_list:
+                media_files.extend(
+                    self._process_feeder_record(
+                        record, RecordType(record_type), device_id
+                    )
+                )
+
+        return media_files
+
+    def _process_feeder_record(
+        self, record, record_type: RecordType, device_id: int
+    ) -> list[MediaFile]:
+        """Process individual feeder records."""
+        media_files: list[MediaFile] = []
+        user_id = record.user_id
+
+        if not record.items:
+            return media_files
+
+        for item in record.items:
+            timestamp = self._get_timestamp(item)
+            date_str = (
+                datetime.fromtimestamp(timestamp).strftime("%Y%m%d")
+                if timestamp
+                else "unknown"
+            )
+            if not item.event_id:
+                _LOGGER.error("Missing event_id for record item")
+                continue
+            if not user_id:
+                _LOGGER.error("Missing user_id for record item")
+                continue
+            if not item.aes_key:
+                _LOGGER.error("Missing aes_key for record item")
+                continue
+            if timestamp is None:
+                _LOGGER.error("Missing timestamp for record item")
+                continue
+
+            filepath = f"{device_id}/{date_str}/{record_type.name.lower()}"
+            media_files.append(
+                MediaFile(
+                    event_id=item.event_id,
+                    event_type=record_type,
+                    device_id=device_id,
+                    user_id=user_id,
+                    image=item.preview,
+                    video=self.construct_video_url(item.media_api, user_id),
+                    filepath=filepath,
+                    aes_key=item.aes_key,
+                    timestamp=self._get_timestamp(item),
+                )
+            )
+        return media_files
+
+    def _process_litter(self, litter: Litter) -> list[MediaFile]:
+        """Process media files for a Litter device."""
+        media_files: list[MediaFile] = []
+        records = litter.device_records
+
+        if not records:
+            return media_files
+
+        for record in records:
+            timestamp = record.timestamp or None
+            date_str = (
+                datetime.fromtimestamp(timestamp).strftime("%Y%m%d")
+                if timestamp
+                else "unknown"
+            )
+            if not record.event_id:
+                _LOGGER.error("Missing event_id for record item")
+                continue
+            if not record.device_id:
+                _LOGGER.error("Missing event_id for record item")
+                continue
+            if not record.user_id:
+                _LOGGER.error("Missing user_id for record item")
+                continue
+            if not record.aes_key:
+                _LOGGER.error("Missing aes_key for record item")
+                continue
+            if record.timestamp is None:
+                _LOGGER.error("Missing timestamp for record item")
+                continue
+
+            filepath = f"{record.device_id}/{date_str}/toileting"
+            media_files.append(
+                MediaFile(
+                    event_id=record.event_id,
+                    event_type=RecordType.TOILETING,
+                    device_id=record.device_id,
+                    user_id=record.user_id,
+                    image=record.preview,
+                    video=self.construct_video_url(record.media_api, record.user_id),
+                    filepath=filepath,
+                    aes_key=record.aes_key,
+                    timestamp=record.timestamp,
+                )
+            )
+        return media_files
+
+    @staticmethod
+    def construct_video_url(media_url: str | None, user_id: str | None) -> str | None:
+        """Construct the video URL."""
+        if not media_url or not user_id:
+            return None
+        params = parse_qs(urlparse(media_url).query)
+        param_dict = {k: v[0] for k, v in params.items()}
+        return f"/d4sh/cloud/video?startTime={param_dict.get("startTime")}&deviceId={param_dict.get("deviceId")}&userId={user_id}&mark={param_dict.get("mark")}"
+
+    @staticmethod
+    def _get_timestamp(item) -> int:
+        """Extract timestamp from a record item and raise an exception if it is None."""
+        timestamp = (
+            item.timestamp
+            or item.completed_at
+            or item.eat_start_time
+            or item.eat_end_time
+            or item.start_time
+            or item.end_time
+            or item.time
+            or None
+        )
+        if timestamp is None:
+            raise ValueError("Can't find timestamp in record item")
+        return timestamp
+
+
+class DownloadDecryptMedia:
+    """Class to download and decrypt media files from PetKit devices."""
+
+    file_data: MediaFile
+
+    def __init__(self, download_path: Path, client: PetKitClient):
+        """Initialize the class."""
+        self.download_path = download_path
+        self.client = client
+
+    async def get_fpath(self, file_name: str) -> Path:
+        """Return the full path of the file."""
+        subdir = ""
+        if file_name.endswith(".jpg"):
+            subdir = "snapshot"
+        elif file_name.endswith(".avi"):
+            subdir = "video"
+        return Path(self.download_path / self.file_data.filepath / subdir / file_name)
+
+    async def download_file(self, file_data: MediaFile) -> None:
+        """Get image and video file"""
+        self.file_data = file_data
+
+        if self.file_data.image:
+            # Download image file
+            await self._get_file(
+                self.file_data.image,
+                self.file_data.aes_key,
+                f"{self.file_data.event_id}.jpg",
+            )
+
+        if self.file_data.video:
+            # Download video file
+            await self._get_video_m3u8()
+
+    async def _get_video_m3u8(self) -> None:
+        """Iterate through m3u8 file and return all the ts file urls"""
+        aes_key, iv_key, segments_lst = await self._get_m3u8_segments()
+
+        segment_files = []
+        for index, segment in enumerate(segments_lst, start=1):
+            segment_file = await self._get_file(
+                segment, aes_key, f"{index}_{self.file_data.event_id}.avi"
+            )
+            if segment_file:
+                segment_files.append(
+                    await self.get_fpath(f"{index}_{self.file_data.event_id}.avi")
+                )
+
+        if len(segment_files) > 1:
+            _LOGGER.debug("Concatenating segments %s", len(segment_files))
+            await self._concat_segments(segment_files, f"{self.file_data.event_id}.avi")
+        elif len(segment_files) == 1:
+            _LOGGER.debug("Single file segment, no need to concatenate")
+
+    async def _get_m3u8_segments(self) -> tuple[str, str, list[str]]:
+        """Extract the segments from a m3u8 file.
+        :return: Tuple of AES key, IV key, and list of segment URLs
+        """
+        if not self.file_data.video:
+            raise ValueError("Missing video URL")
+        video_data = await self.client.get_cloud_video(self.file_data.video)
+
+        media_api = video_data.get("mediaApi", None)
+        if not media_api:
+            _LOGGER.error("Missing mediaApi in video data")
+            raise ValueError("Missing mediaApi in video data")
+        return await self.client.extract_segments_m3u8(str(media_api))
+
+    async def _get_file(self, url: str, aes_key: str, full_filename: str) -> bool:
+        """Download a file from a URL and decrypt it."""
+
+        full_file_path = await self.get_fpath(full_filename)
+        if full_file_path.exists():
+            _LOGGER.debug("File already exist : %s don't re-download it", full_filename)
+            return True
+
+        # Download the file
+        async with aiohttp.ClientSession() as session, session.get(url) as response:
+            if response.status != 200:
+                _LOGGER.error(
+                    "Failed to download %s, status code: %s", url, response.status
+                )
+                return False
+
+            content = await response.read()
+
+        encrypted_file_path = await self._save_file(content, f"{full_filename}.enc")
+        # Decrypt the image
+        decrypted_data = await self._decrypt_file(encrypted_file_path, aes_key)
+
+        if decrypted_data:
+            _LOGGER.debug("Decrypt was successful")
+            await self._save_file(decrypted_data, full_filename)
+            return True
+        return False
+
+    async def _save_file(self, content: bytes, filename: str) -> Path:
+        """Save content to a file asynchronously and return the file path."""
+        file_path = await self.get_fpath(filename)
+        try:
+            # Ensure the directory exists
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            async with aio_open(file_path, "wb") as file:
+                await file.write(content)
+            _LOGGER.debug("Save file OK : %s", file_path)
+        except PermissionError as e:
+            _LOGGER.error("Save file, permission denied %s: %s", file_path, e)
+        except FileNotFoundError as e:
+            _LOGGER.error("Save file, file/folder not found %s: %s", file_path, e)
+        except OSError as e:
+            _LOGGER.error("Save file, error saving file %s: %s", file_path, e)
+        except Exception as e:  # noqa: BLE001
+            _LOGGER.error(
+                "Save file, unexpected error saving file %s: %s", file_path, e
+            )
+        return file_path
+
+    @staticmethod
+    async def _decrypt_file(file_path: Path, aes_key: str) -> bytes | None:
+        """Decrypt a file using AES encryption.
+        :param file_path: Path to the encrypted file.
+        :param aes_key: AES key used for decryption.
+        :return: Decrypted bytes data.
+        """
+        aes_key = aes_key.removesuffix("\n")
+        key_bytes: bytes = aes_key.encode("utf-8")
+        iv: bytes = b"\x61" * 16
+        cipher: Any = AES.new(key_bytes, AES.MODE_CBC, iv)
+
+        async with aio_open(file_path, "rb") as encrypted_file:
+            encrypted_data: bytes = await encrypted_file.read()
+
+        decrypted_data: bytes = cipher.decrypt(encrypted_data)
+
+        try:
+            decrypted_data = unpad(decrypted_data, AES.block_size)
+        except ValueError as e:
+            _LOGGER.debug("Warning: Padding error occurred, ignoring error: %s", e)
+
+        if Path(file_path).exists():
+            Path(file_path).unlink()
+        return decrypted_data
+
+    async def _concat_segments(self, ts_files: list[Path], output_file):
+        """Concatenate a list of .ts segments into a single output file without using a temporary file.
+
+        :param ts_files: List of absolute paths of .ts files
+        :param output_file: Path of the output file (e.g., "output.mp4")
+        """
+        full_output_file = await self.get_fpath(output_file)
+        if full_output_file.exists():
+            _LOGGER.debug(
+                "Output file already exists: %s, skipping concatenation.", output_file
+            )
+            return
+
+        # Build the argument for `ffmpeg` with the files formatted for the command line
+        concat_input = "|".join(str(file) for file in ts_files)
+        command = [
+            "ffmpeg",
+            "-i",
+            f"concat:{concat_input}",
+            "-c",
+            "copy",
+            "-bsf:a",
+            "aac_adtstoasc",
+            str(full_output_file),
+        ]
+
+        try:
+            # Run the subprocess asynchronously
+            process = await asyncio.create_subprocess_exec(
+                *command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await process.communicate()
+
+            if process.returncode == 0:
+                _LOGGER.debug("File successfully concatenated: %s", full_output_file)
+                await self._delete_segments(ts_files)
+            else:
+                _LOGGER.error(
+                    "Error during concatenation: %s\nStdout: %s\nStderr: %s",
+                    process.returncode,
+                    stdout.decode().strip(),
+                    stderr.decode().strip(),
+                )
+        except FileNotFoundError as e:
+            _LOGGER.error("Error during concatenation: %s", e)
+        except OSError as e:
+            _LOGGER.error("OS error during concatenation: %s", e)
+
+    async def _delete_segments(self, ts_files: list[Path]) -> None:
+        """Delete all segment files after concatenation."""
+        for file in ts_files:
+            if file.exists():
+                try:
+                    file.unlink()
+                    _LOGGER.debug("Deleted segment file: %s", file)
+                except OSError as e:
+                    _LOGGER.debug("Error deleting segment file %s: %s", file, e)
+            else:
+                _LOGGER.debug("Segment file not found: %s", file)