pypetkitapi 1.10.3__py3-none-any.whl → 1.11.2__py3-none-any.whl

pypetkitapi/__init__.py

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

pypetkitapi/bluetooth.py

@@ -77,10 +77,10 @@ class BluetoothManager:
         _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.")
+            _LOGGER.error("BLE relay not available (id: %s).", fountain_id)
             return False
         if water_fountain.is_connected is True:
-            _LOGGER.error("BLE connection already established.")
+            _LOGGER.error("BLE connection already established (id %s)", fountain_id)
             return True
         response = await self.client.req.request(
             method=HTTPMethod.POST,
@@ -89,11 +89,16 @@ class BluetoothManager:
             headers=await self.client.get_session_id(),
         )
         if response != {"state": 1}:
-            _LOGGER.error("Failed to establish BLE connection.")
+            _LOGGER.error("Unable to open a BLE connection (id %s)", fountain_id)
             water_fountain.is_connected = False
             return False
         for attempt in range(BLE_CONNECT_ATTEMPT):
-            _LOGGER.warning("BLE connection attempt n%s", attempt)
+            _LOGGER.debug(
+                "BLE connection... %s/%s (id %s)",
+                attempt,
+                BLE_CONNECT_ATTEMPT,
+                fountain_id,
+            )
             response = await self.client.req.request(
                 method=HTTPMethod.POST,
                 url=PetkitEndpoint.BLE_POLL,
@@ -101,14 +106,20 @@ class BluetoothManager:
                 headers=await self.client.get_session_id(),
             )
             if response == 1:
-                _LOGGER.info("BLE connection established successfully.")
+                _LOGGER.info(
+                    "BLE connection established successfully (id %s)", fountain_id
+                )
                 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.")
+        _LOGGER.error(
+            "Failed to establish BLE connection after %s attempts (id %s)",
+            BLE_CONNECT_ATTEMPT,
+            fountain_id,
+        )
         water_fountain.is_connected = False
         return False
 
@@ -116,13 +127,20 @@ class BluetoothManager:
         """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)
+
+        if water_fountain.is_connected is False:
+            _LOGGER.error(
+                "BLE connection not established. Cannot close (id %s)", fountain_id
+            )
+            return
+
         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.")
+        _LOGGER.info("BLE connection closed successfully (id %s)", fountain_id)
 
     async def get_ble_cmd_data(
         self, fountain_command: list, counter: int
@@ -146,11 +164,13 @@ class BluetoothManager:
         _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.")
+            _LOGGER.error("BLE connection not established (id %s)", fountain_id)
             return False
         command_data = FOUNTAIN_COMMAND.get(command)
         if command_data is None:
-            _LOGGER.error("Command not found.")
+            _LOGGER.error(
+                "BLE fountain command '%s' not found (id %s)", command, fountain_id
+            )
             return False
         cmd_code, cmd_data = await self.get_ble_cmd_data(
             list(command_data), water_fountain.ble_counter
@@ -168,7 +188,7 @@ class BluetoothManager:
             headers=await self.client.get_session_id(),
         )
         if response != 1:
-            _LOGGER.error("Failed to send BLE command.")
+            _LOGGER.error("Failed to send BLE command (id %s)", fountain_id)
             return False
-        _LOGGER.info("BLE command sent successfully.")
+        _LOGGER.info("BLE command sent successfully (id %s)", fountain_id)
         return True

pypetkitapi/client.py

@@ -101,8 +101,12 @@ class PetKitClient:
         self.bluetooth_manager = BluetoothManager(self)
         from pypetkitapi import MediaManager
 
+        from . import __version__
+
         self.media_manager = MediaManager()
 
+        _LOGGER.debug("PetKit Client initialized (version %s)", __version__)
+
     async def _get_base_url(self) -> None:
         """Get the list of API servers, filter by region, and return the matching server."""
         _LOGGER.debug("Getting API server list")
@@ -337,7 +341,7 @@ class PetKitClient:
         _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.medias = await self.media_manager.gather_all_media_from_cloud(
             [device_entity]
         )
 
@@ -518,8 +522,8 @@ class PetKitClient:
             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 ?"
+            _LOGGER.warning(
+                "No video data found from cloud, looks like you don't have a care+ subscription ? or video is not uploaded yet."
             )
             return None
         return response[0]

pypetkitapi/const.py

@@ -102,7 +102,7 @@ LOGIN_DATA = {
 class MediaType(StrEnum):
     """Record Type constants"""
 
-    VIDEO = "avi"
+    VIDEO = "mp4"
     IMAGE = "jpg"
 
 

pypetkitapi/media.py

@@ -18,13 +18,14 @@ import aiohttp
 from Crypto.Cipher import AES
 from Crypto.Util.Padding import unpad
 
-from pypetkitapi import Feeder, Litter, PetKitClient, RecordType
+from pypetkitapi import Feeder, Litter, PetKitClient, RecordsItems, RecordType
 from pypetkitapi.const import (
     FEEDER_WITH_CAMERA,
     LITTER_WITH_CAMERA,
     MediaType,
     RecordTypeLST,
 )
+from pypetkitapi.litter_container import LitterRecord
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -65,7 +66,7 @@ class MediaManager:
 
     media_table: list[MediaFile] = []
 
-    async def get_all_media_files(
+    async def gather_all_media_from_cloud(
         self, devices: list[Feeder | Litter]
     ) -> list[MediaCloud]:
         """Get all media files from all devices and return a list of MediaCloud.
@@ -81,7 +82,7 @@ class MediaManager:
                     device.device_nfo
                     and device.device_nfo.device_type in FEEDER_WITH_CAMERA
                 ):
-                    media_files.extend(self._process_feeder(device))
+                    media_files.extend(await self._process_feeder(device))
                 else:
                     _LOGGER.debug(
                         "Feeder %s does not support media file extraction",
@@ -92,7 +93,7 @@ class MediaManager:
                     device.device_nfo
                     and device.device_nfo.device_type in LITTER_WITH_CAMERA
                 ):
-                    media_files.extend(self._process_litter(device))
+                    media_files.extend(await self._process_litter(device))
                 else:
                     _LOGGER.debug(
                         "Litter %s does not support media file extraction",
@@ -101,9 +102,9 @@ class MediaManager:
 
         return media_files
 
-    async def get_all_media_files_disk(
+    async def gather_all_media_from_disk(
         self, storage_path: Path, device_id: int
-    ) -> None:
+    ) -> list[MediaFile]:
         """Construct the media file table for disk storage.
         :param storage_path: Path to the storage directory
         :param device_id: Device ID
@@ -113,29 +114,33 @@ class MediaManager:
         today_str = datetime.now().strftime("%Y%m%d")
         base_path = storage_path / str(device_id) / today_str
 
+        _LOGGER.debug("Populating files from directory %s", base_path)
+
         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)$")
+            valid_pattern = re.compile(
+                rf"^{device_id}_\d+\.({MediaType.IMAGE}|{MediaType.VIDEO})$"
+            )
 
             # 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)
+                    _LOGGER.debug("Path does not exist, skip : %s", subdir)
                     continue
 
-                _LOGGER.debug("Scanning directory %s", subdir)
+                _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("Entries found: %s", entry.name)
+                        _LOGGER.debug("Media found: %s", entry.name)
                         event_id = Path(entry.name).stem
-                        timestamp = self._extract_timestamp(str(entry.name))
+                        timestamp = Path(entry.name).stem.split("_")[1]
                         media_type_str = Path(entry.name).suffix.lstrip(".")
                         try:
                             media_type = MediaType(media_type_str)
@@ -152,19 +157,10 @@ class MediaManager:
                                 media_type=MediaType(media_type),
                             )
                         )
+        _LOGGER.debug("OK, Media table populated with %s files", len(self.media_table))
+        return self.media_table
 
-    @staticmethod
-    def _extract_timestamp(file_name: str) -> int:
-        """Extract timestamp from a filename.
-        :param file_name: Filename
-        :return: Timestamp
-        """
-        match = re.search(r"_(\d+)\.[a-zA-Z0-9]+$", file_name)
-        if match:
-            return int(match.group(1))
-        return 0
-
-    async def prepare_missing_files(
+    async def list_missing_files(
         self,
         media_cloud_list: list[MediaCloud],
         dl_type: list[MediaType] | None = None,
@@ -176,17 +172,29 @@ class MediaManager:
         :param event_type: List of event types to filter
         :return: List of missing MediaCloud objects
         """
-        missing_media = []
+        missing_media: list[MediaCloud] = []
         existing_event_ids = {media_file.event_id for media_file in self.media_table}
 
+        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"
+            )
+            return missing_media
+
         for media_cloud in media_cloud_list:
-            # Skip if event type is not in the filter
+            # 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
 
             # 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
@@ -200,6 +208,9 @@ class MediaManager:
                         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 (
@@ -212,14 +223,16 @@ class MediaManager:
                         for media_file in self.media_table
                     )
                 ):
+                    _LOGGER.debug(
+                        "Media file VIDEO id : %s is missing", media_cloud.event_id
+                    )
                     is_missing = True
 
             if is_missing:
                 missing_media.append(media_cloud)
-
         return missing_media
 
-    def _process_feeder(self, feeder: Feeder) -> list[MediaCloud]:
+    async def _process_feeder(self, feeder: Feeder) -> list[MediaCloud]:
         """Process media files for a Feeder device.
         :param feeder: Feeder device object
         :return: List of MediaCloud objects for the device
@@ -235,12 +248,14 @@ class MediaManager:
             record_list = getattr(records, record_type, [])
             for record in record_list:
                 media_files.extend(
-                    self._process_feeder_record(record, RecordType(record_type), feeder)
+                    await self._process_feeder_record(
+                        record, RecordType(record_type), feeder
+                    )
                 )
 
         return media_files
 
-    def _process_feeder_record(
+    async def _process_feeder_record(
         self, record, record_type: RecordType, device_obj: Feeder
     ) -> list[MediaCloud]:
         """Process individual feeder records.
@@ -260,33 +275,34 @@ class MediaManager:
         )
 
         if not feeder_id:
-            _LOGGER.error("Missing feeder_id for record")
+            _LOGGER.warning("Missing feeder_id for record")
             return media_files
 
         if not record.items:
             return media_files
 
         for item in record.items:
-            timestamp = self._get_timestamp(item)
-            date_str = (
-                datetime.fromtimestamp(timestamp).strftime("%Y%m%d")
-                if timestamp
-                else "unknown"
-            )
+            if not isinstance(item, RecordsItems):
+                _LOGGER.debug("Record is empty")
+                continue
+            timestamp = await self._get_timestamp(item)
+            if timestamp is None:
+                _LOGGER.warning("Missing timestamp for record item")
+                continue
             if not item.event_id:
                 # Skip feed event in the future
-                _LOGGER.debug("Missing event_id for record item")
+                _LOGGER.debug(
+                    "Missing event_id for record item (probably a feed event not yet completed)"
+                )
                 continue
             if not user_id:
-                _LOGGER.error("Missing user_id for record item")
+                _LOGGER.warning("Missing user_id for record item")
                 continue
             if not item.aes_key:
-                _LOGGER.error("Missing aes_key for record item")
-                continue
-            if timestamp is None:
-                _LOGGER.error("Missing timestamp for record item")
+                _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()}"
             media_files.append(
                 MediaCloud(
@@ -295,17 +311,17 @@ class MediaManager:
                     device_id=feeder_id,
                     user_id=user_id,
                     image=item.preview,
-                    video=self.construct_video_url(
+                    video=await 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),
+                    timestamp=timestamp,
                 )
             )
         return media_files
 
-    def _process_litter(self, litter: Litter) -> list[MediaCloud]:
+    async def _process_litter(self, litter: Litter) -> list[MediaCloud]:
         """Process media files for a Litter device.
         :param litter: Litter device object
         :return: List of MediaCloud objects for the device
@@ -318,37 +334,37 @@ class MediaManager:
         cp_sub = litter.cloud_product.subscribe if litter.cloud_product else None
 
         if not litter_id:
-            _LOGGER.error("Missing litter_id for record")
+            _LOGGER.warning("Missing litter_id for record")
             return media_files
 
         if not device_type:
-            _LOGGER.error("Missing device_type for record")
+            _LOGGER.warning("Missing device_type for record")
             return media_files
 
         if not user_id:
-            _LOGGER.error("Missing user_id for record")
+            _LOGGER.warning("Missing user_id for record")
             return media_files
 
         if not records:
             return media_files
 
         for record in records:
-            timestamp = record.timestamp or None
-            date_str = (
-                datetime.fromtimestamp(timestamp).strftime("%Y%m%d")
-                if timestamp
-                else "unknown"
-            )
+            if not isinstance(record, LitterRecord):
+                _LOGGER.debug("Record is empty")
+                continue
             if not record.event_id:
-                _LOGGER.error("Missing event_id for record item")
+                _LOGGER.debug("Missing event_id for record item")
                 continue
             if not record.aes_key:
-                _LOGGER.error("Missing aes_key for record item")
+                _LOGGER.debug("Missing aes_key for record item")
                 continue
             if record.timestamp is None:
-                _LOGGER.error("Missing timestamp for record item")
+                _LOGGER.debug("Missing timestamp for record item")
                 continue
 
+            timestamp = record.timestamp or None
+            date_str = await self.get_date_from_ts(timestamp)
+
             filepath = f"{litter_id}/{date_str}/toileting"
             media_files.append(
                 MediaCloud(
@@ -357,7 +373,7 @@ class MediaManager:
                     device_id=litter_id,
                     user_id=user_id,
                     image=record.preview,
-                    video=self.construct_video_url(
+                    video=await self.construct_video_url(
                         device_type, record.media_api, user_id, cp_sub
                     ),
                     filepath=filepath,
@@ -368,7 +384,17 @@ class MediaManager:
         return media_files
 
     @staticmethod
-    def construct_video_url(
+    async def get_date_from_ts(timestamp: int | None) -> str:
+        """Get date from timestamp.
+        :param timestamp: Timestamp
+        :return: Date string
+        """
+        if not timestamp:
+            return "unknown"
+        return datetime.fromtimestamp(timestamp).strftime("%Y%m%d")
+
+    @staticmethod
+    async 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.
@@ -385,12 +411,12 @@ class MediaManager:
         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:
+    async def _get_timestamp(item) -> int | None:
         """Extract timestamp from a record item and raise an exception if it is None.
         :param item: Record item
         :return: Timestamp
         """
-        timestamp = (
+        return (
             item.timestamp
             or item.completed_at
             or item.eat_start_time
@@ -400,9 +426,6 @@ class MediaManager:
             or item.time
             or None
         )
-        if timestamp is None:
-            raise ValueError("Can't find timestamp in record item")
-        return timestamp
 
 
 class DownloadDecryptMedia:
@@ -421,66 +444,87 @@ class DownloadDecryptMedia:
         :return: Full path of the file.
         """
         subdir = ""
-        if file_name.endswith(".jpg"):
+        if file_name.endswith(MediaType.IMAGE):
             subdir = "snapshot"
-        elif file_name.endswith(".avi"):
+        elif file_name.endswith(MediaType.VIDEO):
             subdir = "video"
         return Path(self.download_path / self.file_data.filepath / subdir / file_name)
 
     async def download_file(
-        self, file_data: MediaCloud, file_type: MediaType | None
+        self, file_data: MediaCloud, file_type: list[MediaType] | None
     ) -> None:
-        """Get image and video file
-        :param file_data: MediaCloud object
-        :param file_type: MediaType object
-        """
-        _LOGGER.debug("Downloading media file %s", file_data.event_id)
+        """Get image and video files."""
         self.file_data = file_data
+        if not file_type:
+            file_type = []
+        filename = f"{self.file_data.device_id}_{self.file_data.timestamp}"
+
+        if self.file_data.image and MediaType.IMAGE in file_type:
+            full_filename = f"{filename}.{MediaType.IMAGE}"
+            if await self.not_existing_file(full_filename):
+                # Image download
+                _LOGGER.debug("Download image file (event id: %s)", file_data.event_id)
+                await self._get_file(
+                    self.file_data.image,
+                    self.file_data.aes_key,
+                    f"{self.file_data.device_id}_{self.file_data.timestamp}.{MediaType.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,
-                self.file_data.aes_key,
-                f"{self.file_data.event_id}.jpg",
-            )
+        if self.file_data.video and MediaType.VIDEO in file_type:
+            if await self.not_existing_file(f"{filename}.{MediaType.VIDEO}"):
+                # Video download
+                _LOGGER.debug("Download video file (event id: %s)", file_data.event_id)
+                await self._get_video_m3u8()
 
-        if self.file_data.video and (file_type is None or file_type == MediaType.VIDEO):
-            # Download video file
-            await self._get_video_m3u8()
+    async def not_existing_file(self, file_name: str) -> bool:
+        """Check if the file already exists.
+        :param file_name: Filename
+        :return: True if the file exists, False otherwise.
+        """
+        full_file_path = await self.get_fpath(file_name)
+        if full_file_path.exists():
+            _LOGGER.debug(
+                "File already exist : %s don't re-download it", full_file_path
+            )
+            return False
+        return True
 
     async def _get_video_m3u8(self) -> None:
-        """Iterate through m3u8 file and return all the ts file urls"""
+        """Iterate through m3u8 file and return all the ts file URLs."""
         aes_key, iv_key, segments_lst = await self._get_m3u8_segments()
+        file_name = (
+            f"{self.file_data.device_id}_{self.file_data.timestamp}.{MediaType.VIDEO}"
+        )
 
         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)
+            _LOGGER.debug("Can't download video file %s", file_name)
             return
 
-        segment_files = []
-
         if len(segments_lst) == 1:
-            await self._get_file(
-                segments_lst[0], aes_key, f"{self.file_data.event_id}.avi"
-            )
+            await self._get_file(segments_lst[0], aes_key, file_name)
             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"
-            )
-            if segment_file:
-                segment_files.append(
-                    await self.get_fpath(f"{index}_{self.file_data.event_id}.avi")
-                )
+        # Download segments in parallel
+        tasks = [
+            self._get_file(segment, aes_key, f"{index}_{file_name}")
+            for index, segment in enumerate(segments_lst, start=1)
+        ]
+        results = await asyncio.gather(*tasks)
+
+        # Collect successful downloads
+        segment_files = [
+            await self.get_fpath(f"{index + 1}_{file_name}")
+            for index, success in enumerate(results)
+            if success
+        ]
 
         if not segment_files:
-            _LOGGER.error("No segment files found")
+            _LOGGER.warning("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")
+            await self._concat_segments(segment_files, file_name)
 
     async def _get_m3u8_segments(self) -> tuple[str | None, str | None, list[str]]:
         """Extract the segments from a m3u8 file.
@@ -495,7 +539,7 @@ class DownloadDecryptMedia:
 
         media_api = video_data.get("mediaApi", None)
         if not media_api:
-            _LOGGER.error("Missing mediaApi in video data")
+            _LOGGER.warning("Missing mediaApi in video data")
             raise ValueError("Missing mediaApi in video data")
         return await self.client.extract_segments_m3u8(str(media_api))
 
@@ -506,12 +550,6 @@ class DownloadDecryptMedia:
         :param full_filename: Name of the file to save.
         :return: True if the file was downloaded successfully, False otherwise.
         """
-
-        full_file_path = await self.get_fpath(full_filename)
-        if full_file_path.exists():
-            _LOGGER.debug("File already exist : %s don't re-download it", full_filename)
-            return True
-
         # Download the file
         async with aiohttp.ClientSession() as session, session.get(url) as response:
             if response.status != 200:
@@ -520,11 +558,8 @@ class DownloadDecryptMedia:
                 )
                 return False
 
-            content = await response.read()
-
-        encrypted_file_path = await self._save_file(content, f"{full_filename}.enc")
-        # Decrypt the image
-        decrypted_data = await self._decrypt_file(encrypted_file_path, aes_key)
+            encrypted_data = await response.read()
+        decrypted_data = await self._decrypt_data(encrypted_data, aes_key)
 
         if decrypted_data:
             _LOGGER.debug("Decrypt was successful")
@@ -559,9 +594,9 @@ class DownloadDecryptMedia:
         return file_path
 
     @staticmethod
-    async def _decrypt_file(file_path: Path, aes_key: str) -> bytes | None:
+    async def _decrypt_data(encrypted_data: bytes, aes_key: str) -> bytes | None:
         """Decrypt a file using AES encryption.
-        :param file_path: Path to the encrypted file.
+        :param encrypted_data: Encrypted bytes data.
         :param aes_key: AES key used for decryption.
         :return: Decrypted bytes data.
         """
@@ -569,26 +604,19 @@ class DownloadDecryptMedia:
         key_bytes: bytes = aes_key.encode("utf-8")
         iv: bytes = b"\x61" * 16
         cipher: Any = AES.new(key_bytes, AES.MODE_CBC, iv)
-
-        async with aio_open(file_path, "rb") as encrypted_file:
-            encrypted_data: bytes = await encrypted_file.read()
-
         decrypted_data: bytes = cipher.decrypt(encrypted_data)
 
         try:
             decrypted_data = unpad(decrypted_data, AES.block_size)
         except ValueError as e:
             _LOGGER.debug("Warning: Padding error occurred, ignoring error: %s", e)
-
-        if Path(file_path).exists():
-            Path(file_path).unlink()
         return decrypted_data
 
     async def _concat_segments(self, ts_files: list[Path], output_file) -> None:
-        """Concatenate a list of .avi segments into a single output file without using a temporary file.
+        """Concatenate a list of .mp4 segments into a single output file without using a temporary file.
 
-        :param ts_files: List of absolute paths of .avi files
-        :param output_file: Path of the output file (e.g., "output.avi")
+        :param ts_files: List of absolute paths of .mp4 files
+        :param output_file: Path of the output file (e.g., "output.mp4")
         """
         full_output_file = await self.get_fpath(output_file)
         if full_output_file.exists():
@@ -635,9 +663,10 @@ class DownloadDecryptMedia:
         except OSError as e:
             _LOGGER.error("OS error during concatenation: %s", e)
 
-    async def _delete_segments(self, ts_files: list[Path]) -> None:
+    @staticmethod
+    async def _delete_segments(ts_files: list[Path]) -> None:
         """Delete all segment files after concatenation.
-        :param ts_files: List of absolute paths of .avi files
+        :param ts_files: List of absolute paths of .mp4 files
         """
         for file in ts_files:
             if file.exists():

{pypetkitapi-1.10.3.dist-info → pypetkitapi-1.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.10.3
+Version: 1.11.2
 Summary: Python client for PetKit API
 License: MIT
 Author: Jezza34000
@@ -77,7 +77,7 @@ import asyncio
 import logging
 import aiohttp
 from pypetkitapi.client import PetKitClient
-from pypetkitapi.command import DeviceCommand, FeederCommand, LBCommand, LBAction, LitterCommand
+from pypetkitapi.command import DeviceCommand, FeederCommand, LBCommand, DeviceAction, LitterCommand
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -86,8 +86,8 @@ async def main():
         client = PetKitClient(
             username="username",  # Your PetKit account username or id
             password="password",  # Your PetKit account password
-            region="FR",  # Your region or country code (e.g. FR, US, etc.)
-            timezone="Europe/Paris",  # Your timezone
+            region="FR",  # Your region or country code (e.g. FR, US,CN etc.)
+            timezone="Europe/Paris",  # Your timezone(e.g. "Asia/Shanghai")
             session=session,
         )
 
@@ -98,26 +98,28 @@ async def main():
         for key, value in client.petkit_entities.items():
             print(f"{key}: {type(value).__name__} - {value.name}")
 
+        # Select a device
+        device_id = key
         # Read devices or pet information
-        print(client.petkit_entities[123456789])
+        print(client.petkit_entities[device_id])
 
         # Send command to the devices
         ### Example 1 : Turn on the indicator light
         ### Device_ID, Command, Payload
-        await client.send_api_request(123456789, DeviceCommand.UPDATE_SETTING, {"lightMode": 1})
+        await client.send_api_request(device_id, DeviceCommand.UPDATE_SETTING, {"lightMode": 1})
 
         ### Example 2 : Feed the pet
         ### Device_ID, Command, Payload
         # simple hopper :
-        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount": 1})
+        await client.send_api_request(device_id, FeederCommand.MANUAL_FEED, {"amount": 1})
         # dual hopper :
-        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount1": 2})
+        await client.send_api_request(device_id, FeederCommand.MANUAL_FEED, {"amount1": 2})
         # or
-        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount2": 2})
+        await client.send_api_request(device_id, FeederCommand.MANUAL_FEED, {"amount2": 2})
 
         ### Example 3 : Start the cleaning process
         ### Device_ID, Command, Payload
-        await client.send_api_request(123456789, LitterCommand.CONTROL_DEVICE, {LBAction.START: LBCommand.CLEANING})
+        await client.send_api_request(device_id, LitterCommand.CONTROL_DEVICE, {DeviceAction.START: LBCommand.CLEANING})
 
 
 if __name__ == "__main__":

{pypetkitapi-1.10.3.dist-info → pypetkitapi-1.11.2.dist-info}/RECORD

@@ -1,19 +1,19 @@
-pypetkitapi/__init__.py,sha256=qP06yQAfRHrJ7yiYlQgNDJD5cGUggj29WsKLhsR_P8M,2107
-pypetkitapi/bluetooth.py,sha256=u_xGp701WnrroTOt_KuIVUCZ3kRQ7BJeoMR8b9RpJ54,7176
-pypetkitapi/client.py,sha256=mbND1lzu1DQ2hHxcQnyk9-8ig1JJ5lAo8S-3lGKmYXs,27037
+pypetkitapi/__init__.py,sha256=qDhET_P65lnwbZgZnkYst3IgJxPlID7fLqYnfVSzJqM,2107
+pypetkitapi/bluetooth.py,sha256=eu6c2h6YHBafAhhSSy4As6tn29i5WbOH9tZzRlMm44U,7843
+pypetkitapi/client.py,sha256=wzZQUHg_ee6lmdAjli6zS7qw_sgPER9iLfcTZe4VTH4,27190
 pypetkitapi/command.py,sha256=cMCUutZCQo9Ddvjl_FYR5UjU_CqFz1iyetMznYwjpzM,7500
-pypetkitapi/const.py,sha256=US5QihmBYvlm8hIHX0PORPUnMmDW3nmLzwLWTepkkGg,4609
+pypetkitapi/const.py,sha256=W0cWpBvOySEaPvVAnQHLeIWYEqKG051mVNv-qsfjo7I,4609
 pypetkitapi/containers.py,sha256=F_uyDBD0a5QD4s_ArjYiKTAAg1XHYBvmV_lEnO9RQ-U,4786
 pypetkitapi/exceptions.py,sha256=4BXUyYXLfZjNxdnOGJPjyE9ASIl7JmQphjws87jvHtE,1631
 pypetkitapi/feeder_container.py,sha256=PhidWd5WpsZqtdKZy60PzE67YXgQfApjm8CqvMCHK3U,14743
 pypetkitapi/litter_container.py,sha256=KWvHNAOJ6hDSeJ_55tqtzY9GxHtd9gAntPkbnVbdb-I,19275
-pypetkitapi/media.py,sha256=OrtEN9LKe3Xy4AapvTUCj4LZ09ZAltGpRYEmD_xQwcA,24220
+pypetkitapi/media.py,sha256=34q3pIfejO_z-Uk8ohQlOGaPOdaGtnI0zN1LtZ3k3F4,25904
 pypetkitapi/purifier_container.py,sha256=ssyIxhNben5XJ4KlQTXTrtULg2ji6DqHqjzOq08d1-I,2491
 pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypetkitapi/schedule_container.py,sha256=OjLAY6FY-g14JNJJnYMNFV5ZtdkjUzNBit1VUiiZKnQ,2053
 pypetkitapi/utils.py,sha256=z7325kcJQUburnF28HSXrJMvY_gY9007K73Zwxp-4DQ,743
 pypetkitapi/water_fountain_container.py,sha256=5J0b-fDZYcFLNX2El7fifv8H6JMhBCt-ttxSow1ozRQ,6787
-pypetkitapi-1.10.3.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
-pypetkitapi-1.10.3.dist-info/METADATA,sha256=OyJ5ainwvLr8ZSkZVM6Dt3cfLlqR1SRE2kXgiq5rBUs,6256
-pypetkitapi-1.10.3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pypetkitapi-1.10.3.dist-info/RECORD,,
+pypetkitapi-1.11.2.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
+pypetkitapi-1.11.2.dist-info/METADATA,sha256=8HbQJ6UeGion-oO5Y5U0X7THfeDRYeP-EK-XVwF_Lb8,6338
+pypetkitapi-1.11.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pypetkitapi-1.11.2.dist-info/RECORD,,