pypetkitapi 1.9.4__tar.gz → 1.10.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.9.4
+Version: 1.10.2
 Summary: Python client for PetKit API
 License: MIT
 Author: Jezza34000

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

@@ -23,24 +23,35 @@ from .const import (
     DEVICES_WATER_FOUNTAIN,
     FEEDER,
     FEEDER_MINI,
+    FEEDER_WITH_CAMERA,
     K2,
     K3,
+    LITTER_NO_CAMERA,
+    LITTER_WITH_CAMERA,
     T3,
     T4,
     T5,
     T6,
     W5,
+    MediaType,
     RecordType,
 )
 from .containers import Pet
-from .exceptions import PetkitAuthenticationError, PypetkitError
+from .exceptions import (
+    PetkitAuthenticationUnregisteredEmailError,
+    PetkitRegionalServerNotFoundError,
+    PetkitSessionError,
+    PetkitSessionExpiredError,
+    PetkitTimeoutError,
+    PypetkitError,
+)
 from .feeder_container import Feeder, RecordsItems
 from .litter_container import Litter, LitterRecord, WorkState
-from .media import DownloadDecryptMedia, MediaFile, MediaManager
+from .media import DownloadDecryptMedia, MediaCloud, MediaFile, MediaManager
 from .purifier_container import Purifier
 from .water_fountain_container import WaterFountain
 
-__version__ = "1.9.4"
+__version__ = "1.10.2"
 
 __all__ = [
     "CTW3",
@@ -53,6 +64,9 @@ __all__ = [
     "DEVICES_LITTER_BOX",
     "DEVICES_PURIFIER",
     "DEVICES_WATER_FOUNTAIN",
+    "FEEDER_WITH_CAMERA",
+    "LITTER_WITH_CAMERA",
+    "LITTER_NO_CAMERA",
     "DeviceAction",
     "DeviceCommand",
     "FEEDER",
@@ -67,11 +81,17 @@ __all__ = [
     "LitterRecord",
     "MediaManager",
     "DownloadDecryptMedia",
+    "MediaCloud",
     "MediaFile",
+    "MediaType",
     "Pet",
     "PetCommand",
     "PetKitClient",
-    "PetkitAuthenticationError",
+    "PetkitAuthenticationUnregisteredEmailError",
+    "PetkitRegionalServerNotFoundError",
+    "PetkitSessionError",
+    "PetkitSessionExpiredError",
+    "PetkitTimeoutError",
     "PurMode",
     "Purifier",
     "PypetkitError",

pypetkitapi-1.10.2/pypetkitapi/bluetooth.py

@@ -0,0 +1,174 @@
+"""Module for handling Bluetooth communication with PetKit devices."""
+
+import asyncio
+import base64
+from datetime import datetime
+from http import HTTPMethod
+import logging
+from typing import TYPE_CHECKING
+import urllib.parse
+
+from pypetkitapi.command import FOUNTAIN_COMMAND, FountainAction
+from pypetkitapi.const import (
+    BLE_CONNECT_ATTEMPT,
+    BLE_END_TRAME,
+    BLE_START_TRAME,
+    PetkitEndpoint,
+)
+from pypetkitapi.containers import BleRelay
+
+if TYPE_CHECKING:
+    from pypetkitapi import PetKitClient, WaterFountain
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BluetoothManager:
+    """Class for handling Bluetooth communication with PetKit devices."""
+
+    def __init__(self, client: "PetKitClient"):
+        """Initialize the BluetoothManager class."""
+        self.client = client
+
+    async def _get_fountain_instance(self, fountain_id: int) -> "WaterFountain":
+        """Get the WaterFountain instance for the given fountain_id."""
+        from pypetkitapi.water_fountain_container import WaterFountain
+
+        water_fountain = self.client.petkit_entities.get(fountain_id)
+        if not isinstance(water_fountain, WaterFountain):
+            _LOGGER.error("Water fountain with ID %s not found.", fountain_id)
+            raise TypeError(f"Water fountain with ID {fountain_id} not found.")
+        return water_fountain
+
+    async def check_relay_availability(self, fountain_id: int) -> bool:
+        """Check if BLE relay is available for the given fountain_id."""
+        fountain = None
+        for account in self.client.account_data:
+            if account.device_list:
+                fountain = next(
+                    (
+                        device
+                        for device in account.device_list
+                        if device.device_id == fountain_id
+                    ),
+                    None,
+                )
+                if fountain:
+                    break
+        if not fountain:
+            raise ValueError(
+                f"Fountain with device_id {fountain_id} not found for the current account"
+            )
+        group_id = fountain.group_id
+        response = await self.client.req.request(
+            method=HTTPMethod.POST,
+            url=f"{PetkitEndpoint.BLE_AS_RELAY}",
+            params={"groupId": group_id},
+            headers=await self.client.get_session_id(),
+        )
+        ble_relays = [BleRelay(**relay) for relay in response]
+        if len(ble_relays) == 0:
+            _LOGGER.warning("No BLE relay devices found.")
+            return False
+        return True
+
+    async def open_ble_connection(self, fountain_id: int) -> bool:
+        """Open a BLE connection to the given fountain_id."""
+        _LOGGER.info("Opening BLE connection to fountain %s", fountain_id)
+        water_fountain = await self._get_fountain_instance(fountain_id)
+        if await self.check_relay_availability(fountain_id) is False:
+            _LOGGER.error("BLE relay not available.")
+            return False
+        if water_fountain.is_connected is True:
+            _LOGGER.error("BLE connection already established.")
+            return True
+        response = await self.client.req.request(
+            method=HTTPMethod.POST,
+            url=PetkitEndpoint.BLE_CONNECT,
+            data={"bleId": fountain_id, "type": 24, "mac": water_fountain.mac},
+            headers=await self.client.get_session_id(),
+        )
+        if response != {"state": 1}:
+            _LOGGER.error("Failed to establish BLE connection.")
+            water_fountain.is_connected = False
+            return False
+        for attempt in range(BLE_CONNECT_ATTEMPT):
+            _LOGGER.warning("BLE connection attempt n%s", attempt)
+            response = await self.client.req.request(
+                method=HTTPMethod.POST,
+                url=PetkitEndpoint.BLE_POLL,
+                data={"bleId": fountain_id, "type": 24, "mac": water_fountain.mac},
+                headers=await self.client.get_session_id(),
+            )
+            if response == 1:
+                _LOGGER.info("BLE connection established successfully.")
+                water_fountain.is_connected = True
+                water_fountain.last_ble_poll = datetime.now().strftime(
+                    "%Y-%m-%dT%H:%M:%S.%f"
+                )
+                return True
+            await asyncio.sleep(4)
+        _LOGGER.error("Failed to establish BLE connection after multiple attempts.")
+        water_fountain.is_connected = False
+        return False
+
+    async def close_ble_connection(self, fountain_id: int) -> None:
+        """Close the BLE connection to the given fountain_id."""
+        _LOGGER.info("Closing BLE connection to fountain %s", fountain_id)
+        water_fountain = await self._get_fountain_instance(fountain_id)
+        await self.client.req.request(
+            method=HTTPMethod.POST,
+            url=PetkitEndpoint.BLE_CANCEL,
+            data={"bleId": fountain_id, "type": 24, "mac": water_fountain.mac},
+            headers=await self.client.get_session_id(),
+        )
+        _LOGGER.info("BLE connection closed successfully.")
+
+    async def get_ble_cmd_data(
+        self, fountain_command: list, counter: int
+    ) -> tuple[int, str]:
+        """Get the BLE command data for the given fountain_command."""
+        cmd_code = fountain_command[0]
+        modified_command = fountain_command[:2] + [counter] + fountain_command[2:]
+        ble_data = [*BLE_START_TRAME, *modified_command, *BLE_END_TRAME]
+        encoded_data = await self._encode_ble_data(ble_data)
+        return cmd_code, encoded_data
+
+    @staticmethod
+    async def _encode_ble_data(byte_list: list) -> str:
+        """Encode the given byte_list to a base64 encoded string."""
+        byte_array = bytearray(byte_list)
+        b64_encoded = base64.b64encode(byte_array)
+        return urllib.parse.quote(b64_encoded)
+
+    async def send_ble_command(self, fountain_id: int, command: FountainAction) -> bool:
+        """Send the given BLE command to the fountain_id."""
+        _LOGGER.info("Sending BLE command to fountain %s", fountain_id)
+        water_fountain = await self._get_fountain_instance(fountain_id)
+        if water_fountain.is_connected is False:
+            _LOGGER.error("BLE connection not established.")
+            return False
+        command_data = FOUNTAIN_COMMAND.get(command)
+        if command_data is None:
+            _LOGGER.error("Command not found.")
+            return False
+        cmd_code, cmd_data = await self.get_ble_cmd_data(
+            list(command_data), water_fountain.ble_counter
+        )
+        response = await self.client.req.request(
+            method=HTTPMethod.POST,
+            url=PetkitEndpoint.BLE_CONTROL_DEVICE,
+            data={
+                "bleId": water_fountain.id,
+                "cmd": cmd_code,
+                "data": cmd_data,
+                "mac": water_fountain.mac,
+                "type": 24,
+            },
+            headers=await self.client.get_session_id(),
+        )
+        if response != 1:
+            _LOGGER.error("Failed to send BLE command.")
+            return False
+        _LOGGER.info("BLE command sent successfully.")
+        return True

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

@@ -1,23 +1,19 @@
 """Pypetkit Client: A Python library for interfacing with PetKit"""
 
 import asyncio
-import base64
 from datetime import datetime, timedelta
 from enum import StrEnum
 import hashlib
 from http import HTTPMethod
 import logging
-import urllib.parse
 
 import aiohttp
 from aiohttp import ContentTypeError
 import m3u8
 
-from pypetkitapi.command import ACTIONS_MAP, FOUNTAIN_COMMAND, FountainAction
+from pypetkitapi.bluetooth import BluetoothManager
+from pypetkitapi.command import ACTIONS_MAP
 from pypetkitapi.const import (
-    BLE_CONNECT_ATTEMPT,
-    BLE_END_TRAME,
-    BLE_START_TRAME,
     CLIENT_NFO,
     DEVICE_DATA,
     DEVICE_RECORDS,
@@ -27,6 +23,7 @@ from pypetkitapi.const import (
     DEVICES_PURIFIER,
     DEVICES_WATER_FOUNTAIN,
     ERR_KEY,
+    FEEDER_WITH_CAMERA,
     LITTER_NO_CAMERA,
     LITTER_WITH_CAMERA,
     LOGIN_DATA,
@@ -40,14 +37,7 @@ from pypetkitapi.const import (
     PetkitDomain,
     PetkitEndpoint,
 )
-from pypetkitapi.containers import (
-    AccountData,
-    BleRelay,
-    Device,
-    Pet,
-    RegionInfo,
-    SessionInfo,
-)
+from pypetkitapi.containers import AccountData, Device, Pet, RegionInfo, SessionInfo
 from pypetkitapi.exceptions import (
     PetkitAuthenticationError,
     PetkitAuthenticationUnregisteredEmailError,
@@ -84,10 +74,6 @@ _LOGGER = logging.getLogger(__name__)
 class PetKitClient:
     """Petkit Client"""
 
-    _session: SessionInfo | None = None
-    account_data: list[AccountData] = []
-    petkit_entities: dict[int, Feeder | Litter | WaterFountain | Purifier | Pet] = {}
-
     def __init__(
         self,
         username: str,
@@ -101,14 +87,21 @@ class PetKitClient:
         self.password = password
         self.region = region.lower()
         self.timezone = timezone
-        self._session = None
-        self.petkit_entities = {}
+        self._session: SessionInfo | None = None
+        self.account_data: list[AccountData] = []
+        self.petkit_entities: dict[
+            int, Feeder | Litter | WaterFountain | Purifier | Pet
+        ] = {}
         self.aiohttp_session = session or aiohttp.ClientSession()
         self.req = PrepReq(
             base_url=PetkitDomain.PASSPORT_PETKIT,
             session=self.aiohttp_session,
             timezone=self.timezone,
         )
+        self.bluetooth_manager = BluetoothManager(self)
+        from pypetkitapi import MediaManager
+
+        self.media_manager = MediaManager()
 
     async def _get_base_url(self) -> None:
         """Get the list of API servers, filter by region, and return the matching server."""
@@ -259,10 +252,11 @@ class PetKitClient:
             await self._get_account_data()
 
         device_list = self._collect_devices()
-        main_tasks, record_tasks = self._prepare_tasks(device_list)
+        main_tasks, record_tasks, media_tasks = self._prepare_tasks(device_list)
 
         await asyncio.gather(*main_tasks)
         await asyncio.gather(*record_tasks)
+        await asyncio.gather(*media_tasks)
         await self._execute_stats_tasks()
 
         end_time = datetime.now()
@@ -279,10 +273,11 @@ class PetKitClient:
                 _LOGGER.debug("Found %s devices", len(account.device_list))
         return device_list
 
-    def _prepare_tasks(self, device_list: list[Device]) -> tuple[list, list]:
+    def _prepare_tasks(self, device_list: list[Device]) -> tuple[list, list, list]:
         """Prepare main and record tasks based on device types."""
-        main_tasks = []
-        record_tasks = []
+        main_tasks: list = []
+        record_tasks: list = []
+        media_tasks: list = []
 
         for device in device_list:
             device_type = device.device_type
@@ -290,11 +285,14 @@ class PetKitClient:
             if device_type in DEVICES_FEEDER:
                 main_tasks.append(self._fetch_device_data(device, Feeder))
                 record_tasks.append(self._fetch_device_data(device, FeederRecord))
+                self._add_feeder_task_by_type(media_tasks, device_type, device)
 
             elif device_type in DEVICES_LITTER_BOX:
                 main_tasks.append(self._fetch_device_data(device, Litter))
                 record_tasks.append(self._fetch_device_data(device, LitterRecord))
-                self._add_litter_box_tasks(record_tasks, device_type, device)
+                self._add_lb_task_by_type(
+                    record_tasks, media_tasks, device_type, device
+                )
 
             elif device_type in DEVICES_WATER_FOUNTAIN:
                 main_tasks.append(self._fetch_device_data(device, WaterFountain))
@@ -305,16 +303,24 @@ class PetKitClient:
             elif device_type in DEVICES_PURIFIER:
                 main_tasks.append(self._fetch_device_data(device, Purifier))
 
-        return main_tasks, record_tasks
+        return main_tasks, record_tasks, media_tasks
 
-    def _add_litter_box_tasks(
-        self, record_tasks: list, device_type: str, device: Device
+    def _add_lb_task_by_type(
+        self, record_tasks: list, media_tasks: list, device_type: str, device: Device
     ):
         """Add specific tasks for litter box devices."""
-        if device_type in [T3, T4]:
+        if device_type in LITTER_NO_CAMERA:
             record_tasks.append(self._fetch_device_data(device, LitterStats))
-        if device_type in [T5, T6]:
+        if device_type in LITTER_WITH_CAMERA:
             record_tasks.append(self._fetch_device_data(device, PetOutGraph))
+            media_tasks.append(self._fetch_media(device))
+
+    def _add_feeder_task_by_type(
+        self, media_tasks: list, device_type: str, device: Device
+    ):
+        """Add specific tasks for feeder box devices."""
+        if device_type in FEEDER_WITH_CAMERA:
+            media_tasks.append(self._fetch_media(device))
 
     async def _execute_stats_tasks(self) -> None:
         """Execute tasks to populate pet stats."""
@@ -325,6 +331,15 @@ class PetKitClient:
         ]
         await asyncio.gather(*stats_tasks)
 
+    async def _fetch_media(self, device: Device) -> None:
+        """Fetch media data from the PetKit servers."""
+        _LOGGER.debug("Fetching media data for device: %s", device.device_id)
+
+        device_entity = self.petkit_entities[device.device_id]
+        device_entity.medias = await self.media_manager.get_all_media_files(
+            [device_entity]
+        )
+
     async def _fetch_device_data(
         self,
         device: Device,
@@ -494,180 +509,18 @@ class PetKitClient:
                 pet.last_duration_usage = self.get_safe_value(graph.toilet_time)
                 pet.last_device_used = pet_graphs.device_nfo.device_name
 
-    async def _get_fountain_instance(self, fountain_id: int) -> WaterFountain:
-        # Retrieve the water fountain object
-        water_fountain = self.petkit_entities.get(fountain_id)
-        if not isinstance(water_fountain, WaterFountain):
-            _LOGGER.error("Water fountain with ID %s not found.", fountain_id)
-            raise TypeError(f"Water fountain with ID {fountain_id} not found.")
-        return water_fountain
-
-    async def check_relay_availability(self, fountain_id: int) -> bool:
-        """Check if BLE relay is available for the account."""
-        fountain = None
-
-        for account in self.account_data:
-            if account.device_list:
-                fountain = next(
-                    (
-                        device
-                        for device in account.device_list
-                        if device.device_id == fountain_id
-                    ),
-                    None,
-                )
-                if fountain:
-                    break
-
-        if not fountain:
-            raise ValueError(
-                f"Fountain with device_id {fountain_id} not found for the current account"
-            )
-
-        group_id = fountain.group_id
-
-        response = await self.req.request(
-            method=HTTPMethod.POST,
-            url=f"{PetkitEndpoint.BLE_AS_RELAY}",
-            params={"groupId": group_id},
-            headers=await self.get_session_id(),
-        )
-        ble_relays = [BleRelay(**relay) for relay in response]
-
-        if len(ble_relays) == 0:
-            _LOGGER.warning("No BLE relay devices found.")
-            return False
-        return True
-
-    async def open_ble_connection(self, fountain_id: int) -> bool:
-        """Open a BLE connection to a PetKit device."""
-        _LOGGER.info("Opening BLE connection to fountain %s", fountain_id)
-        water_fountain = await self._get_fountain_instance(fountain_id)
-
-        if await self.check_relay_availability(fountain_id) is False:
-            _LOGGER.error("BLE relay not available.")
-            return False
-
-        if water_fountain.is_connected is True:
-            _LOGGER.error("BLE connection already established.")
-            return True
-
-        response = await self.req.request(
-            method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CONNECT,
-            data={
-                "bleId": fountain_id,
-                "type": 24,
-                "mac": water_fountain.mac,
-            },
-            headers=await self.get_session_id(),
-        )
-        if response != {"state": 1}:
-            _LOGGER.error("Failed to establish BLE connection.")
-            water_fountain.is_connected = False
-            return False
-
-        for attempt in range(BLE_CONNECT_ATTEMPT):
-            _LOGGER.warning("BLE connection attempt n%s", attempt)
-            response = await self.req.request(
-                method=HTTPMethod.POST,
-                url=PetkitEndpoint.BLE_POLL,
-                data={
-                    "bleId": fountain_id,
-                    "type": 24,
-                    "mac": water_fountain.mac,
-                },
-                headers=await self.get_session_id(),
-            )
-            if response == 1:
-                _LOGGER.info("BLE connection established successfully.")
-                water_fountain.is_connected = True
-                water_fountain.last_ble_poll = datetime.now().strftime(
-                    "%Y-%m-%dT%H:%M:%S.%f"
-                )
-                return True
-            await asyncio.sleep(4)
-        _LOGGER.error("Failed to establish BLE connection after multiple attempts.")
-        water_fountain.is_connected = False
-        return False
-
-    async def close_ble_connection(self, fountain_id: int) -> None:
-        """Close the BLE connection to a PetKit device."""
-        _LOGGER.info("Closing BLE connection to fountain %s", fountain_id)
-        water_fountain = await self._get_fountain_instance(fountain_id)
-
-        await self.req.request(
-            method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CANCEL,
-            data={
-                "bleId": fountain_id,
-                "type": 24,
-                "mac": water_fountain.mac,
-            },
-            headers=await self.get_session_id(),
-        )
-        _LOGGER.info("BLE connection closed successfully.")
-
-    async def get_ble_cmd_data(
-        self, fountain_command: list, counter: int
-    ) -> tuple[int, str]:
-        """Prepare BLE data by adding start and end trame to the command and extracting the first number."""
-        cmd_code = fountain_command[0]
-        modified_command = fountain_command[:2] + [counter] + fountain_command[2:]
-        ble_data = [*BLE_START_TRAME, *modified_command, *BLE_END_TRAME]
-        encoded_data = await self._encode_ble_data(ble_data)
-        return cmd_code, encoded_data
-
-    @staticmethod
-    async def _encode_ble_data(byte_list: list) -> str:
-        """Encode a list of bytes to a URL encoded base64 string."""
-        byte_array = bytearray(byte_list)
-        b64_encoded = base64.b64encode(byte_array)
-        return urllib.parse.quote(b64_encoded)
-
-    async def send_ble_command(self, fountain_id: int, command: FountainAction) -> bool:
-        """BLE command to a PetKit device."""
-        _LOGGER.info("Sending BLE command to fountain %s", fountain_id)
-        water_fountain = await self._get_fountain_instance(fountain_id)
-
-        if water_fountain.is_connected is False:
-            _LOGGER.error("BLE connection not established.")
-            return False
-
-        command_data = FOUNTAIN_COMMAND.get(command)
-        if command_data is None:
-            _LOGGER.error("Command not found.")
-            return False
-
-        cmd_code, cmd_data = await self.get_ble_cmd_data(
-            list(command_data), water_fountain.ble_counter
-        )
-
-        response = await self.req.request(
-            method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CONTROL_DEVICE,
-            data={
-                "bleId": water_fountain.id,
-                "cmd": cmd_code,
-                "data": cmd_data,
-                "mac": water_fountain.mac,
-                "type": 24,
-            },
-            headers=await self.get_session_id(),
-        )
-        if response != 1:
-            _LOGGER.error("Failed to send BLE command.")
-            return False
-        _LOGGER.info("BLE command sent successfully.")
-        return True
-
-    async def get_cloud_video(self, video_url: str) -> dict[str, str | int]:
+    async def get_cloud_video(self, video_url: str) -> dict[str, str | int] | None:
         """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(),
         )
+        if not isinstance(response, list) or not response:
+            _LOGGER.debug(
+                "No video data found from cloud, looks like you don't have a care+ subscription ?"
+            )
+            return None
         return response[0]
 
     async def extract_segments_m3u8(self, m3u8_url: str) -> tuple[str, str, list[str]]:
@@ -858,9 +711,7 @@ class PrepReq:
                         f"Authentication failed: {error_msg}"
                     )
                 case 125:
-                    raise PetkitAuthenticationUnregisteredEmailError(
-                        f"Authentication failed: {error_msg}"
-                    )
+                    raise PetkitAuthenticationUnregisteredEmailError
                 case _:
                     raise PypetkitError(
                         f"Request failed code : {error_code}, details : {error_msg} url : {url}"

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

@@ -34,12 +34,18 @@ K2 = "k2"
 K3 = "k3"
 PET = "pet"
 
+# Litter
 DEVICES_LITTER_BOX = [T3, T4, T5, T6]
 LITTER_WITH_CAMERA = [T5, T6]
 LITTER_NO_CAMERA = [T3, T4]
+# Feeder
+FEEDER_WITH_CAMERA = [D4H, D4SH]
 DEVICES_FEEDER = [FEEDER, FEEDER_MINI, D3, D4, D4S, D4H, D4SH]
+# Water Fountain
 DEVICES_WATER_FOUNTAIN = [W5, CTW3]
+# Purifier
 DEVICES_PURIFIER = [K2]
+# All devices
 ALL_DEVICES = [
     *DEVICES_LITTER_BOX,
     *DEVICES_FEEDER,

{pypetkitapi-1.9.4 → pypetkitapi-1.10.2}/pypetkitapi/containers.py

@@ -99,6 +99,15 @@ class Pet(BaseModel):
         self.name = self.name or self.pet_name
 
 
+class UserDevice(BaseModel):
+    """Dataclass for user data.
+    Subclass of Devices.
+    """
+
+    id: int | None = None
+    nick: str | None = None
+
+
 class User(BaseModel):
     """Dataclass for user data.
     Subclass of AccountData.

{pypetkitapi-1.9.4 → pypetkitapi-1.10.2}/pypetkitapi/exceptions.py

@@ -22,7 +22,7 @@ class PetkitSessionExpiredError(PypetkitError):
 class PetkitAuthenticationUnregisteredEmailError(PypetkitError):
     """Exception raised when the email is not registered with Petkit."""
 
-    def __init__(self, region: str):
+    def __init__(self):
         """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)

{pypetkitapi-1.9.4 → pypetkitapi-1.10.2}/pypetkitapi/feeder_container.py

@@ -14,7 +14,13 @@ from pypetkitapi.const import (
     FEEDER_MINI,
     PetkitEndpoint,
 )
-from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
+from pypetkitapi.containers import (
+    CloudProduct,
+    Device,
+    FirmwareDetail,
+    UserDevice,
+    Wifi,
+)
 
 
 class FeedItem(BaseModel):
@@ -335,7 +341,9 @@ class Feeder(BaseModel):
     sn: str
     state: StateFeeder | None = None
     timezone: float | None = None
+    user: UserDevice | None = None
     device_nfo: Device | None = None
+    medias: list | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

{pypetkitapi-1.9.4 → pypetkitapi-1.10.2}/pypetkitapi/litter_container.py

@@ -14,7 +14,13 @@ from pypetkitapi.const import (
     T3,
     PetkitEndpoint,
 )
-from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
+from pypetkitapi.containers import (
+    CloudProduct,
+    Device,
+    FirmwareDetail,
+    UserDevice,
+    Wifi,
+)
 
 
 class SettingsLitter(BaseModel):
@@ -445,10 +451,12 @@ class Litter(BaseModel):
     service_status: int | None = Field(None, alias="serviceStatus")
     total_time: int | None = Field(None, alias="totalTime")
     with_k3: int | None = Field(None, alias="withK3")
+    user: UserDevice | None = None
     device_records: list[LitterRecord] | None = None
     device_stats: LitterStats | None = None
     device_pet_graph_out: list[PetOutGraph] | None = None
     device_nfo: Device | None = None
+    medias: list | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

{pypetkitapi-1.9.4 → pypetkitapi-1.10.2}/pypetkitapi/media.py

@@ -7,22 +7,30 @@ from dataclasses import dataclass
 from datetime import datetime
 import logging
 from pathlib import Path
+import re
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
+import aiofiles
 from aiofiles import open as aio_open
+import aiofiles.os
 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
+from pypetkitapi.const import (
+    FEEDER_WITH_CAMERA,
+    LITTER_WITH_CAMERA,
+    MediaType,
+    RecordTypeLST,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @dataclass
-class MediaFile:
+class MediaCloud:
     """Dataclass MediaFile.
     Represents a media file from a PetKit device.
     """
@@ -30,27 +38,46 @@ class MediaFile:
     event_id: str
     event_type: RecordType
     device_id: int
-    user_id: str
+    user_id: int
     image: str | None
     video: str | None
     filepath: str
     aes_key: str
     timestamp: int
-    is_available: bool = False
+
+
+@dataclass
+class MediaFile:
+    """Dataclass MediaFile.
+    Represents a media file into disk.
+    """
+
+    event_id: str
+    device_id: int
+    timestamp: int
+    media_type: MediaType
+    event_type: RecordType
+    full_file_path: Path
 
 
 class MediaManager:
     """Class to manage media files from PetKit devices."""
 
+    media_table: list[MediaFile] = []
+
     async def get_all_media_files(
         self, devices: list[Feeder | Litter]
-    ) -> list[MediaFile]:
+    ) -> list[MediaCloud]:
         """Get all media files from all devices and return a list of MediaFile."""
-        media_files: list[MediaFile] = []
+        media_files: list[MediaCloud] = []
+        _LOGGER.debug("Processing media files for %s devices", len(devices))
 
         for device in devices:
             if isinstance(device, Feeder):
-                if device.device_nfo and device.device_nfo.device_type in [D4SH, D4H]:
+                if (
+                    device.device_nfo
+                    and device.device_nfo.device_type in FEEDER_WITH_CAMERA
+                ):
                     media_files.extend(self._process_feeder(device))
                 else:
                     _LOGGER.debug(
@@ -58,7 +85,10 @@ class MediaManager:
                         device.name,
                     )
             elif isinstance(device, Litter):
-                if device.device_nfo and device.device_nfo.device_type in [T5, T6]:
+                if (
+                    device.device_nfo
+                    and device.device_nfo.device_type in LITTER_WITH_CAMERA
+                ):
                     media_files.extend(self._process_litter(device))
                 else:
                     _LOGGER.debug(
@@ -68,39 +98,147 @@ class MediaManager:
 
         return media_files
 
-    def _process_feeder(self, feeder: Feeder) -> list[MediaFile]:
+    async def get_all_media_files_disk(
+        self, storage_path: Path, device_id: int
+    ) -> None:
+        """Construct the media file table for disk storage."""
+        self.media_table.clear()
+
+        today_str = datetime.now().strftime("%Y%m%d")
+        base_path = storage_path / str(device_id) / today_str
+
+        for record_type in RecordType:
+            record_path = base_path / record_type
+            snapshot_path = record_path / "snapshot"
+            video_path = record_path / "video"
+
+            # Regex pattern to match valid filenames
+            valid_pattern = re.compile(rf"^(?:\d+_)?{device_id}_\d+\.(jpg|avi)$")
+
+            # Populate the media table with event_id from filenames
+            for subdir in [snapshot_path, video_path]:
+
+                # Ensure the directories exist
+                if not await aiofiles.os.path.exists(subdir):
+                    _LOGGER.debug("Skip, path does not exist, %s", subdir)
+                    continue
+
+                _LOGGER.debug("Scanning directory %s", subdir)
+                entries = await aiofiles.os.scandir(subdir)
+                for entry in entries:
+                    if entry.is_file() and valid_pattern.match(entry.name):
+                        _LOGGER.debug("Entries found: %s", entry.name)
+                        event_id = Path(entry.name).stem
+                        timestamp = self._extraire_timestamp(str(entry.name))
+                        media_type_str = Path(entry.name).suffix.lstrip(".")
+                        try:
+                            media_type = MediaType(media_type_str)
+                        except ValueError:
+                            _LOGGER.warning("Unknown media type: %s", media_type_str)
+                            continue
+                        self.media_table.append(
+                            MediaFile(
+                                event_id=event_id,
+                                device_id=device_id,
+                                timestamp=int(timestamp),
+                                event_type=RecordType(record_type),
+                                full_file_path=subdir / entry.name,
+                                media_type=MediaType(media_type),
+                            )
+                        )
+
+    @staticmethod
+    def _extraire_timestamp(nom_fichier: str) -> int:
+        match = re.search(r"_(\d+)\.[a-zA-Z0-9]+$", nom_fichier)
+        if match:
+            return int(match.group(1))
+        return 0
+
+    async def prepare_missing_files(
+        self,
+        media_cloud_list: list[MediaCloud],
+        dl_type: list[MediaType] | None = None,
+        event_type: list[RecordType] | None = None,
+    ) -> list[MediaCloud]:
+        """Compare MediaCloud objects with MediaFile objects and return a list of missing MediaCloud objects."""
+        missing_media = []
+        existing_event_ids = {media_file.event_id for media_file in self.media_table}
+
+        for media_cloud in media_cloud_list:
+            # Skip if event type is not in the filter
+            if event_type and media_cloud.event_type not in event_type:
+                continue
+
+            # Check if the media file is missing
+            is_missing = False
+            if media_cloud.event_id not in existing_event_ids:
+                is_missing = True  # Both image and video are missing
+            else:
+                # Check for missing image
+                if (
+                    media_cloud.image
+                    and MediaType.IMAGE
+                    in (dl_type or [MediaType.IMAGE, MediaType.VIDEO])
+                    and not any(
+                        media_file.event_id == media_cloud.event_id
+                        and media_file.media_type == MediaType.IMAGE
+                        for media_file in self.media_table
+                    )
+                ):
+                    is_missing = True
+                # Check for missing video
+                if (
+                    media_cloud.video
+                    and MediaType.VIDEO
+                    in (dl_type or [MediaType.IMAGE, MediaType.VIDEO])
+                    and not any(
+                        media_file.event_id == media_cloud.event_id
+                        and media_file.media_type == MediaType.VIDEO
+                        for media_file in self.media_table
+                    )
+                ):
+                    is_missing = True
+
+            if is_missing:
+                missing_media.append(media_cloud)
+
+        return missing_media
+
+    def _process_feeder(self, feeder: Feeder) -> list[MediaCloud]:
         """Process media files for a Feeder device."""
-        media_files: list[MediaFile] = []
+        media_files: list[MediaCloud] = []
         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:
+            _LOGGER.debug("No records found for %s", feeder.name)
             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
-                    )
+                    self._process_feeder_record(record, RecordType(record_type), feeder)
                 )
 
         return media_files
 
     def _process_feeder_record(
-        self, record, record_type: RecordType, device_id: int
-    ) -> list[MediaFile]:
+        self, record, record_type: RecordType, device_obj: Feeder
+    ) -> list[MediaCloud]:
         """Process individual feeder records."""
-        media_files: list[MediaFile] = []
-        user_id = record.user_id
+        media_files: list[MediaCloud] = []
+        user_id = device_obj.user.id if device_obj.user else None
+        feeder_id = device_obj.device_nfo.device_id if device_obj.device_nfo else None
+        device_type = (
+            device_obj.device_nfo.device_type if device_obj.device_nfo else None
+        )
+        cp_sub = (
+            device_obj.cloud_product.subscribe if device_obj.cloud_product else None
+        )
+
+        if not feeder_id:
+            _LOGGER.error("Missing feeder_id for record")
+            return media_files
 
         if not record.items:
             return media_files
@@ -113,7 +251,8 @@ class MediaManager:
                 else "unknown"
             )
             if not item.event_id:
-                _LOGGER.error("Missing event_id for record item")
+                # Skip feed event in the future
+                _LOGGER.debug("Missing event_id for record item")
                 continue
             if not user_id:
                 _LOGGER.error("Missing user_id for record item")
@@ -125,15 +264,17 @@ class MediaManager:
                 _LOGGER.error("Missing timestamp for record item")
                 continue
 
-            filepath = f"{device_id}/{date_str}/{record_type.name.lower()}"
+            filepath = f"{feeder_id}/{date_str}/{record_type.name.lower()}"
             media_files.append(
-                MediaFile(
+                MediaCloud(
                     event_id=item.event_id,
                     event_type=record_type,
-                    device_id=device_id,
+                    device_id=feeder_id,
                     user_id=user_id,
                     image=item.preview,
-                    video=self.construct_video_url(item.media_api, user_id),
+                    video=self.construct_video_url(
+                        device_type, item.media_api, user_id, cp_sub
+                    ),
                     filepath=filepath,
                     aes_key=item.aes_key,
                     timestamp=self._get_timestamp(item),
@@ -141,10 +282,26 @@ class MediaManager:
             )
         return media_files
 
-    def _process_litter(self, litter: Litter) -> list[MediaFile]:
+    def _process_litter(self, litter: Litter) -> list[MediaCloud]:
         """Process media files for a Litter device."""
-        media_files: list[MediaFile] = []
+        media_files: list[MediaCloud] = []
         records = litter.device_records
+        litter_id = litter.device_nfo.device_id if litter.device_nfo else None
+        device_type = litter.device_nfo.device_type if litter.device_nfo else None
+        user_id = litter.user.id if litter.user else None
+        cp_sub = litter.cloud_product.subscribe if litter.cloud_product else None
+
+        if not litter_id:
+            _LOGGER.error("Missing litter_id for record")
+            return media_files
+
+        if not device_type:
+            _LOGGER.error("Missing device_type for record")
+            return media_files
+
+        if not user_id:
+            _LOGGER.error("Missing user_id for record")
+            return media_files
 
         if not records:
             return media_files
@@ -159,12 +316,6 @@ class MediaManager:
             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
@@ -172,15 +323,17 @@ class MediaManager:
                 _LOGGER.error("Missing timestamp for record item")
                 continue
 
-            filepath = f"{record.device_id}/{date_str}/toileting"
+            filepath = f"{litter_id}/{date_str}/toileting"
             media_files.append(
-                MediaFile(
+                MediaCloud(
                     event_id=record.event_id,
                     event_type=RecordType.TOILETING,
-                    device_id=record.device_id,
-                    user_id=record.user_id,
+                    device_id=litter_id,
+                    user_id=user_id,
                     image=record.preview,
-                    video=self.construct_video_url(record.media_api, record.user_id),
+                    video=self.construct_video_url(
+                        device_type, record.media_api, user_id, cp_sub
+                    ),
                     filepath=filepath,
                     aes_key=record.aes_key,
                     timestamp=record.timestamp,
@@ -189,13 +342,15 @@ class MediaManager:
         return media_files
 
     @staticmethod
-    def construct_video_url(media_url: str | None, user_id: str | None) -> str | None:
+    def construct_video_url(
+        device_type: str | None, media_url: str | None, user_id: int, cp_sub: int | None
+    ) -> str | None:
         """Construct the video URL."""
-        if not media_url or not user_id:
+        if not media_url or not user_id or cp_sub != 1:
             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")}"
+        return f"/{device_type}/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:
@@ -218,7 +373,7 @@ class MediaManager:
 class DownloadDecryptMedia:
     """Class to download and decrypt media files from PetKit devices."""
 
-    file_data: MediaFile
+    file_data: MediaCloud
 
     def __init__(self, download_path: Path, client: PetKitClient):
         """Initialize the class."""
@@ -234,11 +389,14 @@ class DownloadDecryptMedia:
             subdir = "video"
         return Path(self.download_path / self.file_data.filepath / subdir / file_name)
 
-    async def download_file(self, file_data: MediaFile) -> None:
+    async def download_file(
+        self, file_data: MediaCloud, file_type: MediaType | None
+    ) -> None:
         """Get image and video file"""
+        _LOGGER.debug("Downloading media file %s", file_data.event_id)
         self.file_data = file_data
 
-        if self.file_data.image:
+        if self.file_data.image and (file_type is None or file_type == MediaType.IMAGE):
             # Download image file
             await self._get_file(
                 self.file_data.image,
@@ -246,7 +404,7 @@ class DownloadDecryptMedia:
                 f"{self.file_data.event_id}.jpg",
             )
 
-        if self.file_data.video:
+        if self.file_data.video and (file_type is None or file_type == MediaType.VIDEO):
             # Download video file
             await self._get_video_m3u8()
 
@@ -254,7 +412,18 @@ class DownloadDecryptMedia:
         """Iterate through m3u8 file and return all the ts file urls"""
         aes_key, iv_key, segments_lst = await self._get_m3u8_segments()
 
+        if aes_key is None or iv_key is None or not segments_lst:
+            _LOGGER.debug("Can't download video file %s", self.file_data.event_id)
+            return
+
         segment_files = []
+
+        if len(segments_lst) == 1:
+            await self._get_file(
+                segments_lst[0], aes_key, f"{self.file_data.event_id}.avi"
+            )
+            return
+
         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"
@@ -264,13 +433,15 @@ class DownloadDecryptMedia:
                     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")
+        if not segment_files:
+            _LOGGER.error("No segment files found")
         elif len(segment_files) == 1:
             _LOGGER.debug("Single file segment, no need to concatenate")
+        elif 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")
 
-    async def _get_m3u8_segments(self) -> tuple[str, str, list[str]]:
+    async def _get_m3u8_segments(self) -> tuple[str | None, str | None, list[str]]:
         """Extract the segments from a m3u8 file.
         :return: Tuple of AES key, IV key, and list of segment URLs
         """
@@ -278,6 +449,9 @@ class DownloadDecryptMedia:
             raise ValueError("Missing video URL")
         video_data = await self.client.get_cloud_video(self.file_data.video)
 
+        if not video_data:
+            return None, None, []
+
         media_api = video_data.get("mediaApi", None)
         if not media_api:
             _LOGGER.error("Missing mediaApi in video data")
@@ -371,6 +545,7 @@ class DownloadDecryptMedia:
             _LOGGER.debug(
                 "Output file already exists: %s, skipping concatenation.", output_file
             )
+            await self._delete_segments(ts_files)
             return
 
         # Build the argument for `ffmpeg` with the files formatted for the command line

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

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.9.4"
+version = "1.10.2"
 description = "Python client for PetKit API"
 authors = ["Jezza34000 <info@mail.com>"]
 readme = "README.md"
@@ -209,7 +209,7 @@ ruff = "^0.8.1"
 types-aiofiles = "^24.1.0.20240626"
 
 [tool.bumpver]
-current_version = "1.9.4"
+current_version = "1.10.2"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"