pypetkitapi 1.9.3__tar.gz → 1.9.4__tar.gz

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.9.3
+Version: 1.9.4
 Summary: Python client for PetKit API
-Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
 Author: Jezza34000
 Author-email: info@mail.com
@@ -14,8 +13,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: aiohttp (>=3.10.10,<4.0.0)
+Requires-Dist: m3u8 (>=6.0)
 Requires-Dist: pycryptodome (>=3.19.1,<4.0.0)
 Requires-Dist: pydantic (>=1.10.18,<3.0.0)
+Project-URL: Homepage, https://github.com/Jezza34000/pypetkit
 Description-Content-Type: text/markdown
 
 # Petkit API Client
@@ -110,7 +111,9 @@ async def main():
         # simple hopper :
         await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount": 1})
         # dual hopper :
-        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED_DUAL, {"amount1": 2})
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount1": 2})
+        # or
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount2": 2})
 
         ### Example 3 : Start the cleaning process
         ### Device_ID, Command, Payload

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/README.md

@@ -90,7 +90,9 @@ async def main():
         # simple hopper :
         await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount": 1})
         # dual hopper :
-        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED_DUAL, {"amount1": 2})
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount1": 2})
+        # or
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount2": 2})
 
         ### Example 3 : Start the cleaning process
         ### Device_ID, Command, Payload

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/pypetkitapi/__init__.py

@@ -36,11 +36,11 @@ from .containers import Pet
 from .exceptions import PetkitAuthenticationError, PypetkitError
 from .feeder_container import Feeder, RecordsItems
 from .litter_container import Litter, LitterRecord, WorkState
-from .medias import MediaHandler, MediasFiles
+from .media import DownloadDecryptMedia, MediaFile, MediaManager
 from .purifier_container import Purifier
 from .water_fountain_container import WaterFountain
 
-__version__ = "1.9.3"
+__version__ = "1.9.4"
 
 __all__ = [
     "CTW3",
@@ -65,8 +65,9 @@ __all__ = [
     "Litter",
     "LitterCommand",
     "LitterRecord",
-    "MediaHandler",
-    "MediasFiles",
+    "MediaManager",
+    "DownloadDecryptMedia",
+    "MediaFile",
     "Pet",
     "PetCommand",
     "PetKitClient",

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/pypetkitapi/client.py

@@ -11,6 +11,7 @@ import urllib.parse
 
 import aiohttp
 from aiohttp import ContentTypeError
+import m3u8
 
 from pypetkitapi.command import ACTIONS_MAP, FOUNTAIN_COMMAND, FountainAction
 from pypetkitapi.const import (
@@ -53,6 +54,7 @@ from pypetkitapi.exceptions import (
     PetkitInvalidHTTPResponseCodeError,
     PetkitInvalidResponseFormat,
     PetkitRegionalServerNotFoundError,
+    PetkitSessionError,
     PetkitSessionExpiredError,
     PetkitTimeoutError,
     PypetkitError,
@@ -148,6 +150,7 @@ class PetKitClient:
     async def login(self, valid_code: str | None = None) -> None:
         """Login to the PetKit service and retrieve the appropriate server."""
         # Retrieve the list of servers
+        self._session = None
         await self._get_base_url()
 
         _LOGGER.info("Logging in to PetKit server")
@@ -180,6 +183,8 @@ class PetKitClient:
         )
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
+        expiration_date = datetime.now() + timedelta(seconds=self._session.expires_in)
+        _LOGGER.debug("Login successful (token expiration %s)", expiration_date)
 
     async def refresh_session(self) -> None:
         """Refresh the session."""
@@ -193,6 +198,7 @@ class PetKitClient:
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
         self._session.refreshed_at = datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")
+        _LOGGER.debug("Session refreshed at %s", self._session.refreshed_at)
 
     async def validate_session(self) -> None:
         """Check if the session is still valid and refresh or re-login if necessary."""
@@ -201,31 +207,27 @@ class PetKitClient:
             await self.login()
             return
 
-        created_at = datetime.strptime(
-            self._session.created_at,
-            "%Y-%m-%dT%H:%M:%S.%f%z",
+        created = datetime.strptime(self._session.created_at, "%Y-%m-%dT%H:%M:%S.%f%z")
+        is_expired = datetime.now(tz=created.tzinfo) - created >= timedelta(
+            seconds=self._session.expires_in
         )
-        current_time = datetime.now(tz=created_at.tzinfo)
-        token_age = current_time - created_at
-        max_age = timedelta(seconds=self._session.expires_in)
-        half_max_age = max_age / 2
 
-        if token_age > max_age:
+        if is_expired:
             _LOGGER.debug("Token expired, re-logging in")
             await self.login()
-        elif half_max_age < token_age <= max_age:
-            _LOGGER.debug("Token still OK, but refreshing session")
-            await self.refresh_session()
+        # elif (max_age / 2) < token_age < max_age:
+        #     _LOGGER.debug("Token still OK, but refreshing session")
+        #     await self.refresh_session()
 
     async def get_session_id(self) -> dict:
         """Return the session ID."""
+        await self.validate_session()
         if self._session is None:
-            raise PypetkitError("Session is not initialized.")
+            raise PetkitSessionError("No session ID available")
         return {"F-Session": self._session.id, "X-Session": self._session.id}
 
     async def _get_account_data(self) -> None:
         """Get the account data from the PetKit service."""
-        await self.validate_session()
         _LOGGER.debug("Fetching account data")
         response = await self.req.request(
             method=HTTPMethod.GET,
@@ -252,8 +254,6 @@ class PetKitClient:
 
     async def get_devices_data(self) -> None:
         """Get the devices data from the PetKit servers."""
-        await self.validate_session()
-
         start_time = datetime.now()
         if not self.account_data:
             await self._get_account_data()
@@ -661,6 +661,46 @@ class PetKitClient:
         _LOGGER.info("BLE command sent successfully.")
         return True
 
+    async def get_cloud_video(self, video_url: str) -> dict[str, str | int]:
+        """Get the video m3u8 link from the cloud."""
+        response = await self.req.request(
+            method=HTTPMethod.POST,
+            url=video_url,
+            headers=await self.get_session_id(),
+        )
+        return response[0]
+
+    async def extract_segments_m3u8(self, m3u8_url: str) -> tuple[str, str, list[str]]:
+        """Extract segments from the m3u8 file.
+        :param: m3u8_url: URL of the m3u8 file
+        :return: aes_key, key_iv, segment_lst
+        """
+        # Extract segments from m3u8 file
+        response = await self.req.request(
+            method=HTTPMethod.GET,
+            url=m3u8_url,
+            headers=await self.get_session_id(),
+        )
+        m3u8_obj = m3u8.loads(response[RES_KEY])
+
+        if not m3u8_obj.segments or not m3u8_obj.keys:
+            raise PetkitInvalidResponseFormat("No segments or key found in m3u8 file.")
+
+        # Extract segments from m3u8 file
+        segment_lst = [segment.uri for segment in m3u8_obj.segments]
+        # Extract key_uri and key_iv from m3u8 file
+        key_uri = m3u8_obj.keys[0].uri
+        key_iv = str(m3u8_obj.keys[0].iv)
+
+        # Extract aes_key from video segments
+        response = await self.req.request(
+            method=HTTPMethod.GET,
+            url=key_uri,
+            full_url=True,
+            headers=await self.get_session_id(),
+        )
+        return response[RES_KEY], key_iv, segment_lst
+
     async def send_api_request(
         self,
         device_id: int,
@@ -668,8 +708,6 @@ class PetKitClient:
         setting: dict | None = None,
     ) -> bool:
         """Control the device using the PetKit API."""
-        await self.validate_session()
-
         device = self.petkit_entities.get(device_id, None)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
@@ -767,12 +805,13 @@ class PrepReq:
         self,
         method: str,
         url: str,
+        full_url: bool = False,
         params=None,
         data=None,
         headers=None,
     ) -> dict:
         """Make a request to the PetKit API."""
-        _url = "/".join(s.strip("/") for s in [self.base_url, url])
+        _url = url if full_url else "/".join(s.strip("/") for s in [self.base_url, url])
         _headers = {**self.base_headers, **(headers or {})}
         _LOGGER.debug("Request: %s %s", method, _url)
         try:
@@ -798,12 +837,14 @@ class PrepReq:
             ) from e
 
         try:
-            response_json = await response.json()
+            if response.content_type == "application/json":
+                response_json = await response.json()
+            else:
+                return {RES_KEY: await response.text()}
         except ContentTypeError:
             raise PetkitInvalidResponseFormat(
                 "Response is not in JSON format"
             ) from None
-
         # Check for errors in the response
         if ERR_KEY in response_json:
             error_code = int(response_json[ERR_KEY].get("code", 0))

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/pypetkitapi/command.py

@@ -9,7 +9,6 @@ import json
 from pypetkitapi.const import (
     ALL_DEVICES,
     D3,
-    D4,
     D4H,
     D4S,
     D4SH,
@@ -145,25 +144,28 @@ class CmdData:
 
 def get_endpoint_manual_feed(device):
     """Get the endpoint for the device"""
-    if device.device_nfo.device_type == FEEDER_MINI:
-        return PetkitEndpoint.MANUAL_FEED_MINI
-    if device.device_nfo.device_type == FEEDER:
-        return PetkitEndpoint.MANUAL_FEED_FRESH_ELEMENT
-    return PetkitEndpoint.MANUAL_FEED_DUAL
+    if device.device_nfo.device_type in [FEEDER_MINI, FEEDER]:
+        return PetkitEndpoint.MANUAL_FEED_OLD  # Old endpoint snakecase
+    return PetkitEndpoint.MANUAL_FEED_NEW  # New endpoint camelcase
 
 
 def get_endpoint_reset_desiccant(device):
+    """Get the endpoint for the device"""
+    if device.device_nfo.device_type in [FEEDER_MINI, FEEDER]:
+        return PetkitEndpoint.DESICCANT_RESET_OLD  # Old endpoint snakecase
+    return PetkitEndpoint.DESICCANT_RESET_NEW  # New endpoint camelcase
+
+
+def get_endpoint_update_setting(device):
     """Get the endpoint for the device"""
     if device.device_nfo.device_type == FEEDER_MINI:
-        return PetkitEndpoint.MINI_DESICCANT_RESET
-    if device.device_nfo.device_type == FEEDER:
-        return PetkitEndpoint.FRESH_ELEMENT_DESICCANT_RESET
-    return PetkitEndpoint.DESICCANT_RESET
+        return PetkitEndpoint.UPDATE_SETTING_FEEDER_MINI
+    return PetkitEndpoint.UPDATE_SETTING
 
 
 ACTIONS_MAP = {
     DeviceCommand.UPDATE_SETTING: CmdData(
-        endpoint=PetkitEndpoint.UPDATE_SETTING,
+        endpoint=lambda device: get_endpoint_update_setting(device),
         params=lambda device, setting: {
             "id": device.id,
             "kv": json.dumps(setting),
@@ -199,16 +201,6 @@ ACTIONS_MAP = {
     ),
     FeederCommand.MANUAL_FEED: CmdData(
         endpoint=lambda device: get_endpoint_manual_feed(device),
-        params=lambda device, setting: {
-            "day": datetime.datetime.now().strftime("%Y%m%d"),
-            "deviceId": device.id,
-            "time": "-1",
-            **setting,
-        },
-        supported_device=[FEEDER, FEEDER_MINI, D3, D4, D4H],
-    ),
-    FeederCommand.MANUAL_FEED_DUAL: CmdData(
-        endpoint=PetkitEndpoint.MANUAL_FEED_DUAL,
         params=lambda device, setting: {
             "day": datetime.datetime.now().strftime("%Y%m%d"),
             "deviceId": device.id,
@@ -216,7 +208,7 @@ ACTIONS_MAP = {
             "time": "-1",
             **setting,
         },
-        supported_device=[D4S, D4SH],
+        supported_device=DEVICES_FEEDER,
     ),
     FeederCommand.CANCEL_MANUAL_FEED: CmdData(
         endpoint=lambda device: (

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/pypetkitapi/const.py

@@ -93,6 +93,20 @@ LOGIN_DATA = {
 }
 
 
+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"""
 
@@ -100,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):
@@ -121,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"
@@ -140,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-1.9.3 → pypetkitapi-1.9.4}/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-1.9.4/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)

pypetkitapi-1.9.4/pypetkitapi/schedule_container.py

@@ -0,0 +1,67 @@
+"""Dataclasses for Schedule."""
+
+from datetime import datetime
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field
+
+from pypetkitapi.const import DEVICE_DATA, PetkitEndpoint
+from pypetkitapi.containers import Device
+
+
+class Owner(BaseModel):
+    """Dataclass for Owner Data."""
+
+    device_count: int | None = Field(0, alias="deviceCount")
+    id: str | None = None
+    pet_count: int | None = Field(0, alias="petCount")
+    user_count: int | None = Field(0, alias="userCount")
+
+
+class Type(BaseModel):
+    """Dataclass for Type Data."""
+
+    enable: int | None = None
+    id: str | None = None
+    img: str | None = None
+    is_custom: int | None = Field(0, alias="isCustom")
+    name: str | None = None
+    priority: int | None = None
+    repeat_option: str | None = Field(alias="repeatOption")
+    rpt: str | None = None
+    schedule_appoint: str | None = Field(alias="scheduleAppoint")
+    with_device_type: str | None = Field(alias="withDeviceType")
+    with_pet: int | None = Field(0, alias="withPet")
+
+
+class Schedule(BaseModel):
+    """Dataclass for Schedule Data."""
+
+    data_type: ClassVar[str] = DEVICE_DATA
+
+    alarm_before: int | None = Field(0, alias="alarmBefore")
+    created_at: datetime | None = Field(None, alias="createdAt")
+    device_id: str | None = Field(None, alias="deviceId")
+    device_type: str | None = Field(None, alias="deviceType")
+    id: str | None = None
+    name: str | None = None
+    owner: Owner | None = None
+    repeat: str | None = None
+    status: int | None = None
+    time: datetime | None = None
+    type: Type | None = None
+    user_custom_id: int | None = Field(0, alias="userCustomId")
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.SCHEDULE
+
+    @classmethod
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        return {"limit": 20}

{pypetkitapi-1.9.3 → pypetkitapi-1.9.4}/pyproject.toml

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.9.3"
+version = "1.9.4"
 description = "Python client for PetKit API"
 authors = ["Jezza34000 <info@mail.com>"]
 readme = "README.md"
@@ -200,6 +200,7 @@ aiohttp = "^3.10.10"
 aiofiles = "^24.1.0"
 pycryptodome = "^3.19.1"
 pydantic = ">=1.10.18,<3.0.0"
+m3u8 = ">=6.0"
 
 [tool.poetry.dev-dependencies]
 pre-commit = "^4.0.1"
@@ -208,7 +209,7 @@ ruff = "^0.8.1"
 types-aiofiles = "^24.1.0.20240626"
 
 [tool.bumpver]
-current_version = "1.9.3"
+current_version = "1.9.4"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"

pypetkitapi-1.9.3/pypetkitapi/medias.py

@@ -1,199 +0,0 @@
-"""Module to handle media files from PetKit devices."""
-
-from dataclasses import dataclass
-import logging
-from pathlib import Path
-import re
-from typing import Any
-
-from aiofiles import open as aio_open
-import aiohttp
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import unpad
-
-from pypetkitapi.feeder_container import Feeder, RecordsType
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass
-class MediasFiles:
-    """Dataclass for media files.
-    Subclass of many other device dataclasses.
-    """
-
-    filename: str
-    record_type: str
-    url: str
-    aes_key: str
-    timestamp: str | None = None
-
-
-async def extract_filename_from_url(url: str) -> str:
-    """Extract the filename from the URL and format it as requested."""
-    match = re.search(r"https?://[^/]+(/[^?]+)", url)
-    if match:
-        path = match.group(1)
-        formatted_filename = path.replace("/", "_").lstrip("_").lower()
-        return f"{formatted_filename}.jpg"
-    raise ValueError(f"Failed to extract filename from URL: {url}")
-
-
-class MediaHandler:
-    """Class to find media files from PetKit devices."""
-
-    def __init__(self, file_path: Path):
-        """Initialize the class."""
-        self.media_download_decode = MediaDownloadDecode(file_path)
-        self.media_files: list[MediasFiles] = []
-
-    async def get_last_image(self, device: Feeder) -> list[MediasFiles]:
-        """Process device records and extract media info."""
-        record_types = ["eat", "feed", "move", "pet"]
-        self.media_files = []
-
-        if not isinstance(device, Feeder):
-            _LOGGER.error("Device is not a Feeder")
-            return []
-
-        if not device.device_records:
-            _LOGGER.error("No device records found for feeder")
-            return []
-
-        for record_type in record_types:
-            records = getattr(device.device_records, record_type, None)
-            if records:
-                self.media_files.extend(
-                    await self._process_records(records, record_type)
-                )
-        return self.media_files
-
-    async def _process_records(
-        self, records: RecordsType, record_type: str
-    ) -> list[MediasFiles]:
-        """Process individual records and return media info."""
-        media_files = []
-
-        async def process_item(record_items):
-            last_item = next(
-                (
-                    item
-                    for item in reversed(record_items)
-                    if item.preview and item.aes_key
-                ),
-                None,
-            )
-            if last_item:
-                filename = await extract_filename_from_url(last_item.preview)
-                await self.media_download_decode.get_file(
-                    last_item.preview, last_item.aes_key
-                )
-                timestamp = (
-                    last_item.eat_start_time
-                    or last_item.completed_at
-                    or last_item.timestamp
-                    or None
-                )
-                media_files.append(
-                    MediasFiles(
-                        record_type=record_type,
-                        filename=filename,
-                        url=last_item.preview,
-                        aes_key=last_item.aes_key,
-                        timestamp=timestamp,
-                    )
-                )
-
-        for record in records:
-            if hasattr(record, "items"):
-                await process_item(record.items)  # type: ignore[attr-defined]
-
-        return media_files
-
-
-class MediaDownloadDecode:
-    """Class to download"""
-
-    def __init__(self, download_path: Path):
-        """Initialize the class."""
-        self.download_path = download_path
-
-    async def get_file(self, url: str, aes_key: str) -> bool:
-        """Download a file from a URL and decrypt it."""
-        # Check if the file already exists
-        filename = await extract_filename_from_url(url)
-        full_file_path = Path(self.download_path) / filename
-        if full_file_path.exists():
-            _LOGGER.debug("File already exist : %s don't need to download it", 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"{filename}.enc")
-        # Decrypt the image
-        decrypted_data = await self._decrypt_image_from_file(
-            encrypted_file_path, aes_key
-        )
-
-        if decrypted_data:
-            _LOGGER.debug("Decrypt was successful")
-            await self._save_file(decrypted_data, 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 = Path(self.download_path) / 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_image_from_file(file_path: Path, aes_key: str) -> bytes | None:
-        """Decrypt an image from a file using AES encryption.
-        :param file_path: Path to the encrypted image file.
-        :param aes_key: AES key used for decryption.
-        :return: Decrypted image data.
-        """
-        try:
-            if aes_key.endswith("\n"):
-                aes_key = aes_key[:-1]
-            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 = unpad(
-                cipher.decrypt(encrypted_data), AES.block_size  # type: ignore[attr-defined]
-            )
-        except Exception as e:  # noqa: BLE001
-            logging.error("Error decrypting image from file %s: %s", file_path, e)
-            return None
-        if Path(file_path).exists():
-            Path(file_path).unlink()
-        return decrypted_data