PyPI - pypetkitapi - Versions diffs - 1.11.2__tar.gz → 1.11.5__tar.gz - Mend

pypetkitapi 1.11.2tar.gz → 1.11.5tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.11.2
+Version: 1.11.5
 Summary: Python client for PetKit API
 License: MIT
 Author: Jezza34000
@@ -23,12 +23,14 @@ Description-Content-Type: text/markdown
 ---
-[![PyPI](https://img.shields.io/pypi/v/pypetkitapi.svg)][pypi_]
+[![Lifecycle:Maturing](https://img.shields.io/badge/Lifecycle-Maturing-007EC6)](https://github.com/Jezza34000/py-petkit-api/)
 [![Python Version](https://img.shields.io/pypi/pyversions/pypetkitapi)][python version] [![Actions status](https://github.com/Jezza34000/py-petkit-api/workflows/CI/badge.svg)](https://github.com/Jezza34000/py-petkit-api/actions)
+[![PyPI](https://img.shields.io/pypi/v/pypetkitapi.svg)][pypi_] [![PyPI Downloads](https://static.pepy.tech/badge/pypetkitapi)](https://pepy.tech/projects/pypetkitapi)
 ---
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=ncloc)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
@@ -38,8 +40,6 @@ Description-Content-Type: text/markdown
 [![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
-[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=ncloc)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
 [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
 [![mypy](https://img.shields.io/badge/mypy-checked-blue)](https://mypy.readthedocs.io/en/stable/)
@@ -58,9 +58,10 @@ PetKit Client is a Python library for interacting with the PetKit API. It allows
 ## Features
-Login and session management
-Fetch account and device data
-Control PetKit devices (Feeder, Litter Box, Water Fountain)
+- Login and session management
+- Fetch account and device data
+- Control PetKit devices (Feeder, Litter Box, Water Fountain, Purifiers)
+- Fetch images & videos produced by devices
 ## Installation
@@ -72,6 +73,9 @@ pip install pypetkitapi
 ## Usage Example:
+Here is a simple example of how to use the library to interact with the PetKit API \
+This example is not an exhaustive list of all the features available in the library.
 ```python
 import asyncio
 import logging
@@ -130,9 +134,14 @@ if __name__ == "__main__":
 Check at the usage in the Home Assistant integration : [here](https://github.com/Jezza34000/homeassistant_petkit)
+## Help and Support
+A discord server is available for support and help, check here: [here](https://github.com/Jezza34000/homeassistant_petkit)
 ## Contributing
-Contributions are welcome! Please open an issue or submit a pull request.
+Contributions are welcome!\
+Please open an issue or submit a pull request.
 ## License

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/README.md RENAMED Viewed

@@ -2,12 +2,14 @@
 ---
-[![PyPI](https://img.shields.io/pypi/v/pypetkitapi.svg)][pypi_]
+[![Lifecycle:Maturing](https://img.shields.io/badge/Lifecycle-Maturing-007EC6)](https://github.com/Jezza34000/py-petkit-api/)
 [![Python Version](https://img.shields.io/pypi/pyversions/pypetkitapi)][python version] [![Actions status](https://github.com/Jezza34000/py-petkit-api/workflows/CI/badge.svg)](https://github.com/Jezza34000/py-petkit-api/actions)
+[![PyPI](https://img.shields.io/pypi/v/pypetkitapi.svg)][pypi_] [![PyPI Downloads](https://static.pepy.tech/badge/pypetkitapi)](https://pepy.tech/projects/pypetkitapi)
 ---
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=ncloc)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
@@ -17,8 +19,6 @@
 [![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
-[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=ncloc)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
 [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
 [![mypy](https://img.shields.io/badge/mypy-checked-blue)](https://mypy.readthedocs.io/en/stable/)
@@ -37,9 +37,10 @@ PetKit Client is a Python library for interacting with the PetKit API. It allows
 ## Features
-Login and session management
-Fetch account and device data
-Control PetKit devices (Feeder, Litter Box, Water Fountain)
+- Login and session management
+- Fetch account and device data
+- Control PetKit devices (Feeder, Litter Box, Water Fountain, Purifiers)
+- Fetch images & videos produced by devices
 ## Installation
@@ -51,6 +52,9 @@ pip install pypetkitapi
 ## Usage Example:
+Here is a simple example of how to use the library to interact with the PetKit API \
+This example is not an exhaustive list of all the features available in the library.
 ```python
 import asyncio
 import logging
@@ -109,9 +113,14 @@ if __name__ == "__main__":
 Check at the usage in the Home Assistant integration : [here](https://github.com/Jezza34000/homeassistant_petkit)
+## Help and Support
+A discord server is available for support and help, check here: [here](https://github.com/Jezza34000/homeassistant_petkit)
 ## Contributing
-Contributions are welcome! Please open an issue or submit a pull request.
+Contributions are welcome!\
+Please open an issue or submit a pull request.
 ## License

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/pypetkitapi/__init__.py RENAMED Viewed

@@ -51,7 +51,7 @@ from .media import DownloadDecryptMedia, MediaCloud, MediaFile, MediaManager
 from .purifier_container import Purifier
 from .water_fountain_container import WaterFountain
-__version__ = "1.11.2"
+__version__ = "1.11.5"
 __all__ = [
     "CTW3",

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/pypetkitapi/bluetooth.py RENAMED Viewed

@@ -31,7 +31,10 @@ class BluetoothManager:
         self.client = client
     async def _get_fountain_instance(self, fountain_id: int) -> "WaterFountain":
-        """Get the WaterFountain instance for the given fountain_id."""
+        """Get the WaterFountain instance for the given fountain_id.
+        :param fountain_id: The ID of the fountain to get the instance for.
+        :return: The WaterFountain instance for the given fountain_id.
+        """
         from pypetkitapi.water_fountain_container import WaterFountain
         water_fountain = self.client.petkit_entities.get(fountain_id)
@@ -41,7 +44,10 @@ class BluetoothManager:
         return water_fountain
     async def check_relay_availability(self, fountain_id: int) -> bool:
-        """Check if BLE relay is available for the given fountain_id."""
+        """Check if BLE relay is available for the given fountain_id.
+        :param fountain_id: The ID of the fountain to check the relay for.
+        :return: True if the relay is available, False otherwise.
+        """
         fountain = None
         for account in self.client.account_data:
             if account.device_list:
@@ -73,14 +79,17 @@ class BluetoothManager:
         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)
+        """Open a BLE connection to the given fountain_id.
+        :param fountain_id: The ID of the fountain to open the BLE connection for.
+        :return: True if the BLE connection was established, False otherwise.
+        """
+        _LOGGER.debug("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 (id: %s).", fountain_id)
+            _LOGGER.debug("BLE relay not available (id: %s).", fountain_id)
             return False
         if water_fountain.is_connected is True:
-            _LOGGER.error("BLE connection already established (id %s)", fountain_id)
+            _LOGGER.debug("BLE connection already established (id %s)", fountain_id)
             return True
         response = await self.client.req.request(
             method=HTTPMethod.POST,
@@ -89,7 +98,7 @@ class BluetoothManager:
             headers=await self.client.get_session_id(),
         )
         if response != {"state": 1}:
-            _LOGGER.error("Unable to open a BLE connection (id %s)", fountain_id)
+            _LOGGER.debug("Unable to open a BLE connection (id %s)", fountain_id)
             water_fountain.is_connected = False
             return False
         for attempt in range(BLE_CONNECT_ATTEMPT):
@@ -106,7 +115,7 @@ class BluetoothManager:
                 headers=await self.client.get_session_id(),
             )
             if response == 1:
-                _LOGGER.info(
+                _LOGGER.debug(
                     "BLE connection established successfully (id %s)", fountain_id
                 )
                 water_fountain.is_connected = True
@@ -115,7 +124,7 @@ class BluetoothManager:
                 )
                 return True
             await asyncio.sleep(4)
-        _LOGGER.error(
+        _LOGGER.debug(
             "Failed to establish BLE connection after %s attempts (id %s)",
             BLE_CONNECT_ATTEMPT,
             fountain_id,
@@ -124,12 +133,15 @@ class BluetoothManager:
         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)
+        """Close the BLE connection to the given fountain_id.
+        :param fountain_id: The ID of the fountain to close the BLE connection for.
+        :return: None
+        """
+        _LOGGER.debug("Closing BLE connection to fountain %s", fountain_id)
         water_fountain = await self._get_fountain_instance(fountain_id)
         if water_fountain.is_connected is False:
-            _LOGGER.error(
+            _LOGGER.debug(
                 "BLE connection not established. Cannot close (id %s)", fountain_id
             )
             return
@@ -140,12 +152,16 @@ class BluetoothManager:
             data={"bleId": fountain_id, "type": 24, "mac": water_fountain.mac},
             headers=await self.client.get_session_id(),
         )
-        _LOGGER.info("BLE connection closed successfully (id %s)", fountain_id)
+        _LOGGER.debug("BLE connection closed successfully (id %s)", fountain_id)
     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."""
+        """Get the BLE command data for the given fountain_command.
+        :param fountain_command: The fountain command to get the BLE data for.
+        :param counter: The BLE counter for the fountain.
+        :return: The BLE command code and the encoded BLE data.
+        """
         cmd_code = fountain_command[0]
         modified_command = fountain_command[:2] + [counter] + fountain_command[2:]
         ble_data = [*BLE_START_TRAME, *modified_command, *BLE_END_TRAME]
@@ -154,17 +170,24 @@ class BluetoothManager:
     @staticmethod
     async def _encode_ble_data(byte_list: list) -> str:
-        """Encode the given byte_list to a base64 encoded string."""
+        """Encode the given byte_list to a base64 encoded string.
+        :param byte_list: The byte list to encode.
+        :return: The 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)
+        """Send the given BLE command to the fountain_id.
+        :param fountain_id: The ID of the fountain to send the command to.
+        :param command: The command to send to the fountain.
+        :return: True if the command was sent successfully, False otherwise.
+        """
+        _LOGGER.debug("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 (id %s)", fountain_id)
+            _LOGGER.debug("BLE connection not established (id %s)", fountain_id)
             return False
         command_data = FOUNTAIN_COMMAND.get(command)
         if command_data is None:
@@ -190,5 +213,5 @@ class BluetoothManager:
         if response != 1:
             _LOGGER.error("Failed to send BLE command (id %s)", fountain_id)
             return False
-        _LOGGER.info("BLE command sent successfully (id %s)", fountain_id)
+        _LOGGER.debug("BLE command sent successfully (id %s)", fountain_id)
         return True

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/pypetkitapi/client.py RENAMED Viewed

@@ -6,6 +6,7 @@ from enum import StrEnum
 import hashlib
 from http import HTTPMethod
 import logging
+from typing import Any
 import aiohttp
 from aiohttp import ContentTypeError
@@ -146,7 +147,9 @@ class PetKitClient:
         return False
     async def login(self, valid_code: str | None = None) -> None:
-        """Login to the PetKit service and retrieve the appropriate server."""
+        """Login to the PetKit service and retrieve the appropriate server.
+        :param valid_code: The valid code sent to the user's email.
+        """
         # Retrieve the list of servers
         self._session = None
         await self._get_base_url()
@@ -268,7 +271,9 @@ class PetKitClient:
         _LOGGER.debug("Petkit data fetched successfully in: %s", end_time - start_time)
     def _collect_devices(self) -> list[Device]:
-        """Collect all devices from account data."""
+        """Collect all devices from account data.
+        :return: List of devices.
+        """
         device_list = []
         for account in self.account_data:
             _LOGGER.debug("List devices data for account: %s", account)
@@ -279,7 +284,10 @@ class PetKitClient:
         return device_list
     def _prepare_tasks(self, device_list: list[Device]) -> tuple[list, list, list]:
-        """Prepare main and record tasks based on device types."""
+        """Prepare main and record tasks based on device types.
+        :param device_list: List of devices.
+        :return: Tuple of main tasks, record tasks and media tasks.
+        """
         main_tasks: list = []
         record_tasks: list = []
         media_tasks: list = []
@@ -312,8 +320,13 @@ class PetKitClient:
     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."""
+    ) -> None:
+        """Add specific tasks for litter box devices.
+        :param record_tasks: List of record tasks.
+        :param media_tasks: List of media tasks.
+        :param device_type: Device type.
+        :param device: Device data.
+        """
         if device_type in LITTER_NO_CAMERA:
             record_tasks.append(self._fetch_device_data(device, LitterStats))
         if device_type in LITTER_WITH_CAMERA:
@@ -322,8 +335,12 @@ class PetKitClient:
     def _add_feeder_task_by_type(
         self, media_tasks: list, device_type: str, device: Device
-    ):
-        """Add specific tasks for feeder box devices."""
+    ) -> None:
+        """Add specific tasks for feeder box devices.
+        :param media_tasks: List of media tasks.
+        :param device_type: Device type.
+        :param device: Device data.
+        """
         if device_type in FEEDER_WITH_CAMERA:
             media_tasks.append(self._fetch_media(device))
@@ -337,7 +354,9 @@ class PetKitClient:
         await asyncio.gather(*stats_tasks)
     async def _fetch_media(self, device: Device) -> None:
-        """Fetch media data from the PetKit servers."""
+        """Fetch media data from the PetKit servers.
+        :param device: Device data.
+        """
         _LOGGER.debug("Fetching media data for device: %s", device.device_id)
         device_entity = self.petkit_entities[device.device_id]
@@ -360,7 +379,10 @@ class PetKitClient:
             | LitterStats
         ],
     ) -> None:
-        """Fetch the device data from the PetKit servers."""
+        """Fetch the device data from the PetKit servers.
+        :param device: Device data.
+        :param data_class: Data class
+        """
         device_type = device.device_type
         _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device.device_id)
@@ -398,7 +420,7 @@ class PetKitClient:
             _LOGGER.error("Unexpected response type: %s", type(response))
             return
-        # Dispatch to the appropriate handler
+        # Dispatch to the appropriate data handler
         handler = data_handlers.get(data_class.data_type)
         if handler:
             await handler(self, device, device_data, device_type)
@@ -406,14 +428,21 @@ class PetKitClient:
             _LOGGER.error("Unknown data type: %s", data_class.data_type)
     @data_handler(DEVICE_DATA)
-    async def _handle_device_data(self, device, device_data, device_type):
+    async def _handle_device_data(
+        self,
+        device: Device,
+        device_data: Feeder | Litter | WaterFountain | Purifier,
+        device_type: str,
+    ):
         """Handle device data."""
         self.petkit_entities[device.device_id] = device_data
         self.petkit_entities[device.device_id].device_nfo = device
         _LOGGER.debug("Device data fetched OK for %s", device_type)
     @data_handler(DEVICE_RECORDS)
-    async def _handle_device_records(self, device, device_data, device_type):
+    async def _handle_device_records(
+        self, device: Device, device_data, device_type: str
+    ):
         """Handle device records."""
         entity = self.petkit_entities.get(device.device_id)
         if entity and isinstance(entity, (Feeder, Litter, WaterFountain)):
@@ -426,7 +455,7 @@ class PetKitClient:
             )
     @data_handler(DEVICE_STATS)
-    async def _handle_device_stats(self, device, device_data, device_type):
+    async def _handle_device_stats(self, device: Device, device_data, device_type: str):
         """Handle device stats."""
         entity = self.petkit_entities.get(device.device_id)
         if isinstance(entity, Litter):
@@ -442,7 +471,9 @@ class PetKitClient:
             )
     async def get_pets_list(self) -> list[Pet]:
-        """Extract and return the list of pets."""
+        """Extract and return the list of pets.
+        :return: List of pets.
+        """
         return [
             entity
             for entity in self.petkit_entities.values()
@@ -451,18 +482,28 @@ class PetKitClient:
     @staticmethod
     def get_safe_value(value: int | None, default: int = 0) -> int:
-        """Return the value if not None, otherwise return the default."""
+        """Return the value if not None, otherwise return the default.
+        :param value: Value to check.
+        :param default: Default value.
+        :return: Value or default.
+        """
         return value if value is not None else default
     @staticmethod
     def calculate_duration(start: int | None, end: int | None) -> int:
-        """Calculate the duration, ensuring both start and end are not None."""
+        """Calculate the duration, ensuring both start and end are not None.
+        :param start: Start time.
+        :param end: End time.
+        :return: Duration.
+        """
         if start is None or end is None:
             return 0
         return end - start
     async def populate_pet_stats(self, stats_data: Litter) -> None:
-        """Collect data from litter data to populate pet stats."""
+        """Collect data from litter data to populate pet stats.
+        :param stats_data: Litter data.
+        """
         if not stats_data.device_nfo:
             _LOGGER.warning(
@@ -476,16 +517,21 @@ class PetKitClient:
                 stats_data.device_nfo.device_type in [T3, T4]
                 and stats_data.device_records
             ):
-                await self._process_t3_t4(pet, stats_data)
+                await self._process_litter_no_camera(pet, stats_data)
             elif (
                 stats_data.device_nfo.device_type in [T5, T6]
                 and stats_data.device_pet_graph_out
             ):
-                await self._process_t5_t6(pet, stats_data)
+                await self._process_litter_camera(pet, stats_data)
-    async def _process_t3_t4(self, pet, device_records):
-        """Process T3/T4 devices records."""
-        for stat in device_records.device_records:
+    async def _process_litter_no_camera(self, pet: Pet, device_records: Litter) -> None:
+        """Process litter T3/T4 records (litter without camera).
+        :param pet: Pet data.
+        :param device_records: Litter data.
+        """
+        for stat in (
+            s for s in device_records.device_records or [] if isinstance(s, LitterStats)
+        ):
             if stat.pet_id == pet.pet_id and (
                 pet.last_litter_usage is None
                 or self.get_safe_value(stat.timestamp) > pet.last_litter_usage
@@ -498,24 +544,34 @@ class PetKitClient:
                     stat.content.time_in if stat.content else None,
                     stat.content.time_out if stat.content else None,
                 )
-                pet.last_device_used = device_records.device_nfo.device_name
-    async def _process_t5_t6(self, pet, pet_graphs):
-        """Process T5/T6 pet graphs."""
-        for graph in pet_graphs.device_pet_graph_out:
+                pet.last_device_used = getattr(
+                    device_records.device_nfo, "device_name", "Unknown"
+                ).capitalize()
+    async def _process_litter_camera(self, pet: Pet, pet_graphs: Litter) -> None:
+        """Process litter T5/T6 records (litter WITH camera).
+        :param pet: Pet data.
+        :param pet_graphs: Litter data.
+        """
+        for graph in pet_graphs.device_pet_graph_out or []:
             if graph.pet_id == pet.pet_id and (
                 pet.last_litter_usage is None
                 or self.get_safe_value(graph.time) > pet.last_litter_usage
             ):
-                pet.last_litter_usage = graph.time
+                pet.last_litter_usage = graph.time or 0
                 pet.last_measured_weight = self.get_safe_value(
                     graph.content.pet_weight if graph.content else None
                 )
-                pet.last_duration_usage = self.get_safe_value(graph.toilet_time)
-                pet.last_device_used = pet_graphs.device_nfo.device_name
+                pet.last_duration_usage = self.get_safe_value(graph.toilet_time) or 0
+                pet.last_device_used = getattr(
+                    pet_graphs.device_nfo, "device_name", "Unknown"
+                ).capitalize()
     async def get_cloud_video(self, video_url: str) -> dict[str, str | int] | None:
-        """Get the video m3u8 link from the cloud."""
+        """Get the video m3u8 link from the cloud.
+        :param video_url: URL of the video.
+        :return: Video data.
+        """
         response = await self.req.request(
             method=HTTPMethod.POST,
             url=video_url,
@@ -528,7 +584,9 @@ class PetKitClient:
             return None
         return response[0]
-    async def extract_segments_m3u8(self, m3u8_url: str) -> tuple[str, str, list[str]]:
+    async def extract_segments_m3u8(
+        self, m3u8_url: str
+    ) -> tuple[Any, str | None, list[str | None]]:
         """Extract segments from the m3u8 file.
         :param: m3u8_url: URL of the m3u8 file
         :return: aes_key, key_iv, segment_lst
@@ -542,7 +600,7 @@ class PetKitClient:
         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.")
+            return None, None, []
         # Extract segments from m3u8 file
         segment_lst = [segment.uri for segment in m3u8_obj.segments]
@@ -550,6 +608,9 @@ class PetKitClient:
         key_uri = m3u8_obj.keys[0].uri
         key_iv = str(m3u8_obj.keys[0].iv)
+        if not key_uri or not key_iv:
+            return None, None, []
         # Extract aes_key from video segments
         response = await self.req.request(
             method=HTTPMethod.GET,
@@ -565,7 +626,12 @@ class PetKitClient:
         action: StrEnum,
         setting: dict | None = None,
     ) -> bool:
-        """Control the device using the PetKit API."""
+        """Control the device using the PetKit API.
+        :param device_id: ID of the device.
+        :param action: Action to perform.
+        :param setting: Setting to apply.
+        :return: True if the command was successful, False otherwise.
+        """
         device = self.petkit_entities.get(device_id, None)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
@@ -668,7 +734,15 @@ class PrepReq:
         data=None,
         headers=None,
     ) -> dict:
-        """Make a request to the PetKit API."""
+        """Make a request to the PetKit API.
+        :param method: HTTP method.
+        :param url: URL of the API endpoint.
+        :param full_url: Use full URL.
+        :param params: Parameters to send.
+        :param data: Data to send.
+        :param headers: Headers to send.
+        :return: Response from the API.
+        """
         _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)
@@ -686,7 +760,11 @@ class PrepReq:
     @staticmethod
     async def _handle_response(response: aiohttp.ClientResponse, url: str) -> dict:
-        """Handle the response from the PetKit API."""
+        """Handle the response from the PetKit API.
+        :param response: Response from the API.
+        :param url: URL of the API endpoint.
+        :return: Data from the API.
+        """
         try:
             response.raise_for_status()
         except aiohttp.ClientResponseError as e:

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/pypetkitapi/media.py RENAMED Viewed

@@ -6,6 +6,7 @@ import asyncio
 from dataclasses import dataclass
 from datetime import datetime
 import logging
+import os
 from pathlib import Path
 import re
 from typing import Any
@@ -105,10 +106,7 @@ class MediaManager:
     async def gather_all_media_from_disk(
         self, storage_path: Path, device_id: int
     ) -> list[MediaFile]:
-        """Construct the media file table for disk storage.
-        :param storage_path: Path to the storage directory
-        :param device_id: Device ID
-        """
+        """Construct the media file table for disk storage."""
         self.media_table.clear()
         today_str = datetime.now().strftime("%Y%m%d")
@@ -116,121 +114,171 @@ class MediaManager:
         _LOGGER.debug("Populating files from directory %s", base_path)
+        valid_pattern = re.compile(
+            rf"^{device_id}_\d+\.({MediaType.IMAGE}|{MediaType.VIDEO})$"
+        )
         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"^{device_id}_\d+\.({MediaType.IMAGE}|{MediaType.VIDEO})$"
-            )
+            subdirs = [record_path / "snapshot", record_path / "video"]
+            for subdir in subdirs:
+                await self._process_subdir(
+                    subdir, device_id, record_type, valid_pattern
+                )
-            # 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("Path does not exist, skip : %s", subdir)
-                    continue
-                _LOGGER.debug("Scanning files into : %s", subdir)
-                entries = await aiofiles.os.scandir(subdir)
-                for entry in entries:
-                    if entry.is_file() and valid_pattern.match(entry.name):
-                        _LOGGER.debug("Media found: %s", entry.name)
-                        event_id = Path(entry.name).stem
-                        timestamp = Path(entry.name).stem.split("_")[1]
-                        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),
-                            )
-                        )
         _LOGGER.debug("OK, Media table populated with %s files", len(self.media_table))
         return self.media_table
+    async def _process_subdir(
+        self,
+        subdir: Path,
+        device_id: int,
+        record_type: RecordType,
+        valid_pattern: re.Pattern,
+    ) -> None:
+        """Process a subdirectory to collect media files."""
+        if not await aiofiles.os.path.exists(subdir):
+            _LOGGER.debug("Path does not exist, skip: %s", subdir)
+            return
+        _LOGGER.debug("Scanning files into: %s", subdir)
+        entries = await aiofiles.os.scandir(subdir)
+        for entry in entries:
+            media_file = await self._create_media_file(
+                entry, device_id, record_type, subdir, valid_pattern
+            )
+            if media_file:
+                self.media_table.append(media_file)
+    @staticmethod
+    async def _create_media_file(
+        entry: os.DirEntry,
+        device_id: int,
+        record_type: RecordType,
+        subdir: Path,
+        valid_pattern: re.Pattern,
+    ) -> MediaFile | None:
+        """Create a MediaFile from a directory entry if valid."""
+        if not entry.is_file() or not valid_pattern.match(entry.name):
+            return None
+        try:
+            stem = Path(entry.name).stem
+            parts = stem.split("_")
+            timestamp = int(parts[1])
+            media_type_str = Path(entry.name).suffix.lstrip(".")
+            media_type = MediaType(media_type_str)
+        except (ValueError, IndexError) as e:
+            _LOGGER.warning("Invalid file %s: %s", entry.name, str(e))
+            return None
+        return MediaFile(
+            event_id=stem,
+            device_id=device_id,
+            timestamp=timestamp,
+            media_type=media_type,
+            event_type=record_type,
+            full_file_path=subdir / entry.name,
+        )
     async def list_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.
-        :param media_cloud_list: List of MediaCloud objects
-        :param dl_type: List of media types to download
-        :param event_type: List of event types to filter
-        :return: List of missing MediaCloud objects
-        """
-        missing_media: list[MediaCloud] = []
+        """Compare MediaCloud objects with MediaFile objects and return missing ones."""
+        if not dl_type or not event_type:
+            _LOGGER.debug("Missing dl_type or event_type, no downloads")
+            return []
         existing_event_ids = {media_file.event_id for media_file in self.media_table}
+        return [
+            mc
+            for mc in media_cloud_list
+            if self._should_process_media(mc, event_type, dl_type, existing_event_ids)
+        ]
-        if dl_type is None or event_type is None or not dl_type or not event_type:
-            _LOGGER.debug(
-                "Missing dl_type or event_type parameters, no media file will be downloaded"
+    def _should_process_media(
+        self,
+        media_cloud: MediaCloud,
+        event_filter: list[RecordType],
+        dl_types: list[MediaType],
+        existing_ids: set[str],
+    ) -> bool:
+        """Determine if a media should be processed as missing."""
+        if self._should_skip_event_type(media_cloud.event_type, event_filter):
+            return False
+        return self._is_media_missing(media_cloud, dl_types, existing_ids)
+    @staticmethod
+    def _should_skip_event_type(
+        event_type: RecordType, event_filter: list[RecordType]
+    ) -> bool:
+        """Check if event type should be skipped."""
+        if event_type not in event_filter:
+            _LOGGER.debug("Skipping filtered event type: %s", event_type)
+            return True
+        return False
+    def _is_media_missing(
+        self, media_cloud: MediaCloud, dl_types: list[MediaType], existing_ids: set[str]
+    ) -> bool:
+        """Check if any media type is missing."""
+        missing_image = self._is_image_missing(media_cloud, dl_types, existing_ids)
+        missing_video = self._is_video_missing(media_cloud, dl_types, existing_ids)
+        if missing_image or missing_video:
+            self._log_missing_details(media_cloud, missing_image, missing_video)
+            return True
+        return False
+    def _is_image_missing(
+        self, media_cloud: MediaCloud, dl_types: list[MediaType], existing_ids: set[str]
+    ) -> bool:
+        """Check if image is missing."""
+        return bool(
+            media_cloud.image
+            and MediaType.IMAGE in dl_types
+            and not self._media_exists(
+                media_cloud.event_id, MediaType.IMAGE, existing_ids
             )
-            return missing_media
+        )
-        for media_cloud in media_cloud_list:
-            # Skip if event type is not in the event filter
-            if event_type and media_cloud.event_type not in event_type:
-                _LOGGER.debug(
-                    "Skipping event type %s, is filtered", media_cloud.event_type
-                )
-                continue
+    def _is_video_missing(
+        self, media_cloud: MediaCloud, dl_types: list[MediaType], existing_ids: set[str]
+    ) -> bool:
+        """Check if video is missing."""
+        return bool(
+            media_cloud.video
+            and MediaType.VIDEO in dl_types
+            and not self._media_exists(
+                media_cloud.event_id, MediaType.VIDEO, existing_ids
+            )
+        )
-            # Check if the media file is missing
-            is_missing = False
-            if media_cloud.event_id not in existing_event_ids:
-                _LOGGER.debug(
-                    "Media file IMG/VIDEO id : %s are missing", media_cloud.event_id
-                )
-                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
-                    )
-                ):
-                    _LOGGER.debug(
-                        "Media file IMG id : %s is missing", media_cloud.event_id
-                    )
-                    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
-                    )
-                ):
-                    _LOGGER.debug(
-                        "Media file VIDEO id : %s is missing", media_cloud.event_id
-                    )
-                    is_missing = True
+    def _media_exists(
+        self, event_id: str, media_type: MediaType, existing_ids: set[str]
+    ) -> bool:
+        """Check if media exists in local storage."""
+        for mf in self.media_table:
+            if event_id in existing_ids and mf.media_type == media_type:
+                return True
+        return False
-            if is_missing:
-                missing_media.append(media_cloud)
-        return missing_media
+    @staticmethod
+    def _log_missing_details(
+        media_cloud: MediaCloud, missing_image: bool, missing_video: bool
+    ) -> None:
+        """Log details about missing media."""
+        log_msg = "Media missing for event %s: "
+        details = []
+        if missing_image:
+            details.append("IMAGE")
+        if missing_video:
+            details.append("VIDEO")
+        _LOGGER.debug("%s %s %s", log_msg, media_cloud.event_id, " + ".join(details))
     async def _process_feeder(self, feeder: Feeder) -> list[MediaCloud]:
         """Process media files for a Feeder device.
@@ -270,15 +318,10 @@ class MediaManager:
         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
-        )
+        cp_sub = self.is_subscription_active(device_obj)
-        if not feeder_id:
-            _LOGGER.warning("Missing feeder_id for record")
-            return media_files
-        if not record.items:
+        if not feeder_id or not record.items:
+            _LOGGER.warning("Missing feeder_id or items for record")
             return media_files
         for item in record.items:
@@ -289,18 +332,15 @@ class MediaManager:
             if timestamp is None:
                 _LOGGER.warning("Missing timestamp for record item")
                 continue
-            if not item.event_id:
+            if not item.event_id or not item.aes_key:
                 # Skip feed event in the future
                 _LOGGER.debug(
-                    "Missing event_id for record item (probably a feed event not yet completed)"
+                    "Missing event_id or aes_key for record item (probably a feed event not yet completed, or uploaded)"
                 )
                 continue
             if not user_id:
                 _LOGGER.warning("Missing user_id for record item")
                 continue
-            if not item.aes_key:
-                _LOGGER.warning("Missing aes_key for record item")
-                continue
             date_str = await self.get_date_from_ts(timestamp)
             filepath = f"{feeder_id}/{date_str}/{record_type.name.lower()}"
@@ -331,32 +371,24 @@ class MediaManager:
         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.warning("Missing litter_id for record")
-            return media_files
-        if not device_type:
-            _LOGGER.warning("Missing device_type for record")
-            return media_files
+        cp_sub = self.is_subscription_active(litter)
-        if not user_id:
-            _LOGGER.warning("Missing user_id for record")
+        if not litter_id or not device_type or not user_id:
+            _LOGGER.warning(
+                "Missing one or more of mandatory information : litter_id/device_id/user_id for record"
+            )
             return media_files
         if not records:
+            _LOGGER.debug("No records found for %s", litter.name)
             return media_files
         for record in records:
             if not isinstance(record, LitterRecord):
                 _LOGGER.debug("Record is empty")
                 continue
-            if not record.event_id:
-                _LOGGER.debug("Missing event_id for record item")
-                continue
-            if not record.aes_key:
-                _LOGGER.debug("Missing aes_key for record item")
+            if not record.event_id or not record.aes_key:
+                _LOGGER.debug("Missing event_id or aes_key for record item")
                 continue
             if record.timestamp is None:
                 _LOGGER.debug("Missing timestamp for record item")
@@ -383,6 +415,19 @@ class MediaManager:
             )
         return media_files
+    @staticmethod
+    def is_subscription_active(device: Feeder | Litter) -> bool:
+        """Check if the subscription is active based on the work_indate timestamp.
+        :param device: Device object
+        :return: True if the subscription is active, False otherwise
+        """
+        if device.cloud_product and device.cloud_product.work_indate:
+            return (
+                datetime.fromtimestamp(device.cloud_product.work_indate)
+                > datetime.now()
+            )
+        return False
     @staticmethod
     async def get_date_from_ts(timestamp: int | None) -> str:
         """Get date from timestamp.
@@ -395,7 +440,10 @@ class MediaManager:
     @staticmethod
     async def construct_video_url(
-        device_type: str | None, media_url: str | None, user_id: int, cp_sub: int | None
+        device_type: str | None,
+        media_url: str | None,
+        user_id: int,
+        cp_sub: bool | None,
     ) -> str | None:
         """Construct the video URL.
         :param device_type: Device type
@@ -404,7 +452,7 @@ class MediaManager:
         :param cp_sub: Cpsub value
         :return: Constructed video URL
         """
-        if not media_url or not user_id or cp_sub != 1:
+        if not media_url or not user_id or not cp_sub:
             return None
         params = parse_qs(urlparse(media_url).query)
         param_dict = {k: v[0] for k, v in params.items()}
@@ -523,10 +571,10 @@ class DownloadDecryptMedia:
         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))
+            _LOGGER.debug("Concatenating video with %s segments", len(segment_files))
             await self._concat_segments(segment_files, file_name)
-    async def _get_m3u8_segments(self) -> tuple[str | None, str | None, list[str]]:
+    async def _get_m3u8_segments(self) -> tuple[Any, str | None, list[str | None]]:
         """Extract the segments from a m3u8 file.
         :return: Tuple of AES key, IV key, and list of segment URLs
         """
@@ -539,17 +587,23 @@ class DownloadDecryptMedia:
         media_api = video_data.get("mediaApi", None)
         if not media_api:
-            _LOGGER.warning("Missing mediaApi in video data")
+            _LOGGER.debug("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:
+    async def _get_file(
+        self, url: str | None, aes_key: str | None, full_filename: str | None
+    ) -> bool:
         """Download a file from a URL and decrypt it.
         :param url: URL of the file to download.
         :param aes_key: AES key used for decryption.
         :param full_filename: Name of the file to save.
         :return: True if the file was downloaded successfully, False otherwise.
         """
+        if not url or not aes_key or not full_filename:
+            _LOGGER.debug("Missing URL, AES key, or filename")
+            return False
         # Download the file
         async with aiohttp.ClientSession() as session, session.get(url) as response:
             if response.status != 200:
@@ -609,7 +663,7 @@ class DownloadDecryptMedia:
         try:
             decrypted_data = unpad(decrypted_data, AES.block_size)
         except ValueError as e:
-            _LOGGER.debug("Warning: Padding error occurred, ignoring error: %s", e)
+            _LOGGER.debug("Ignoring unpad warning : %s", e)
         return decrypted_data
     async def _concat_segments(self, ts_files: list[Path], output_file) -> None:

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/pypetkitapi/schedule_container.py RENAMED Viewed

@@ -27,10 +27,10 @@ class Type(BaseModel):
     is_custom: int | None = Field(0, alias="isCustom")
     name: str | None = None
     priority: int | None = None
-    repeat_option: str | None = Field(alias="repeatOption")
+    repeat_option: str | None = Field(None, alias="repeatOption")
     rpt: str | None = None
-    schedule_appoint: str | None = Field(alias="scheduleAppoint")
-    with_device_type: str | None = Field(alias="withDeviceType")
+    schedule_appoint: str | None = Field(None, alias="scheduleAppoint")
+    with_device_type: str | None = Field(None, alias="withDeviceType")
     with_pet: int | None = Field(0, alias="withPet")

{pypetkitapi-1.11.2 → pypetkitapi-1.11.5}/pyproject.toml RENAMED Viewed

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.11.2"
+version = "1.11.5"
 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.11.2"
+current_version = "1.11.5"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"