pypetkitapi 1.10.2__py3-none-any.whl → 1.11.0__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.2"
+__version__ = "1.11.0"
 
 __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,15 +101,20 @@ 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")
         self.req.base_url = PetkitDomain.PASSPORT_PETKIT
 
-        if self.region.lower() == "china":
+        if self.region.lower() == "china" or self.region.lower() == "cn":
             self.req.base_url = PetkitDomain.CHINA_SRV
+            _LOGGER.debug("Using specific China server: %s", PetkitDomain.CHINA_SRV)
             return
 
         response = await self.req.request(
@@ -336,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]
         )
 
@@ -517,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

@@ -31,8 +31,8 @@ _LOGGER = logging.getLogger(__name__)
 
 @dataclass
 class MediaCloud:
-    """Dataclass MediaFile.
-    Represents a media file from a PetKit device.
+    """Dataclass MediaCloud.
+    Represents a media file from Petkit API.
     """
 
     event_id: str
@@ -65,10 +65,13 @@ 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 MediaFile."""
+        """Get all media files from all devices and return a list of MediaCloud.
+        :param devices: List of devices
+        :return: List of MediaCloud objects
+        """
         media_files: list[MediaCloud] = []
         _LOGGER.debug("Processing media files for %s devices", len(devices))
 
@@ -78,7 +81,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",
@@ -89,7 +92,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",
@@ -98,38 +101,45 @@ 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:
-        """Construct the media file table for disk storage."""
+    ) -> list[MediaFile]:
+        """Construct the media file table for disk storage.
+        :param storage_path: Path to the storage directory
+        :param device_id: Device ID
+        """
         self.media_table.clear()
 
         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._extraire_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)
@@ -146,32 +156,44 @@ 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 _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(
+    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."""
-        missing_media = []
+        """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] = []
         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
@@ -185,6 +207,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 (
@@ -197,15 +222,20 @@ 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]:
-        """Process media files for a Feeder device."""
+    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
+        """
         media_files: list[MediaCloud] = []
         records = feeder.device_records
 
@@ -217,15 +247,22 @@ 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."""
+        """Process individual feeder records.
+        :param record: Record object
+        :param record_type: Record type
+        :param device_obj: Feeder device object
+        :return: List of MediaCloud objects for the record
+        """
         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
@@ -244,15 +281,15 @@ class MediaManager:
             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"
-            )
+            timestamp = await self._get_timestamp(item)
+            if timestamp is None:
+                _LOGGER.error("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")
@@ -260,10 +297,8 @@ class MediaManager:
             if not item.aes_key:
                 _LOGGER.error("Missing aes_key for record item")
                 continue
-            if timestamp is None:
-                _LOGGER.error("Missing timestamp for record item")
-                continue
 
+            date_str = await self.get_date_from_ts(timestamp)
             filepath = f"{feeder_id}/{date_str}/{record_type.name.lower()}"
             media_files.append(
                 MediaCloud(
@@ -272,18 +307,21 @@ 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]:
-        """Process media files for a Litter device."""
+    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
+        """
         media_files: list[MediaCloud] = []
         records = litter.device_records
         litter_id = litter.device_nfo.device_id if litter.device_nfo else None
@@ -307,22 +345,19 @@ class MediaManager:
             return media_files
 
         for record in records:
-            timestamp = record.timestamp or None
-            date_str = (
-                datetime.fromtimestamp(timestamp).strftime("%Y%m%d")
-                if timestamp
-                else "unknown"
-            )
             if not record.event_id:
-                _LOGGER.error("Missing event_id for record item")
+                _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(
@@ -331,7 +366,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,
@@ -342,10 +377,26 @@ 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."""
+        """Construct the video URL.
+        :param device_type: Device type
+        :param media_url: Media URL
+        :param user_id: User ID
+        :param cp_sub: Cpsub value
+        :return: Constructed video URL
+        """
         if not media_url or not user_id or cp_sub != 1:
             return None
         params = parse_qs(urlparse(media_url).query)
@@ -353,8 +404,11 @@ 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:
-        """Extract timestamp from a record item and raise an exception if it is None."""
+    async def _get_timestamp(item) -> int:
+        """Extract timestamp from a record item and raise an exception if it is None.
+        :param item: Record item
+        :return: Timestamp
+        """
         timestamp = (
             item.timestamp
             or item.completed_at
@@ -381,57 +435,84 @@ class DownloadDecryptMedia:
         self.client = client
 
     async def get_fpath(self, file_name: str) -> Path:
-        """Return the full path of the file."""
+        """Return the full path of the file.
+        :param file_name: Name of the file.
+        :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"""
-        _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")
@@ -439,7 +520,7 @@ class DownloadDecryptMedia:
             _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.
@@ -459,13 +540,12 @@ class DownloadDecryptMedia:
         return await self.client.extract_segments_m3u8(str(media_api))
 
     async def _get_file(self, url: str, aes_key: str, full_filename: str) -> bool:
-        """Download a file from a URL and decrypt it."""
-
-        full_file_path = await self.get_fpath(full_filename)
-        if full_file_path.exists():
-            _LOGGER.debug("File already exist : %s don't re-download it", full_filename)
-            return True
-
+        """Download 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.
+        """
         # Download the file
         async with aiohttp.ClientSession() as session, session.get(url) as response:
             if response.status != 200:
@@ -474,11 +554,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")
@@ -487,7 +564,11 @@ class DownloadDecryptMedia:
         return False
 
     async def _save_file(self, content: bytes, filename: str) -> Path:
-        """Save content to a file asynchronously and return the file path."""
+        """Save content to a file asynchronously and return the file path.
+        :param content: Bytes data to save.
+        :param filename: Name of the file to save.
+        :return: Path of the saved file.
+        """
         file_path = await self.get_fpath(filename)
         try:
             # Ensure the directory exists
@@ -509,9 +590,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.
         """
@@ -519,25 +600,18 @@ 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):
-        """Concatenate a list of .ts segments into a single output file without using a temporary file.
+    async def _concat_segments(self, ts_files: list[Path], output_file) -> None:
+        """Concatenate a list of .mp4 segments into a single output file without using a temporary file.
 
-        :param ts_files: List of absolute paths of .ts files
+        :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)
@@ -585,8 +659,11 @@ class DownloadDecryptMedia:
         except OSError as e:
             _LOGGER.error("OS error during concatenation: %s", e)
 
-    async def _delete_segments(self, ts_files: list[Path]) -> None:
-        """Delete all segment files after concatenation."""
+    @staticmethod
+    async def _delete_segments(ts_files: list[Path]) -> None:
+        """Delete all segment files after concatenation.
+        :param ts_files: List of absolute paths of .mp4 files
+        """
         for file in ts_files:
             if file.exists():
                 try:

{pypetkitapi-1.10.2.dist-info → pypetkitapi-1.11.0.dist-info}/METADATA

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

{pypetkitapi-1.10.2.dist-info → pypetkitapi-1.11.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-pypetkitapi/__init__.py,sha256=mdImqvI5uFp8gupd6pf9IACfLFVEXEfEO_8PitRyzUo,2107
-pypetkitapi/bluetooth.py,sha256=u_xGp701WnrroTOt_KuIVUCZ3kRQ7BJeoMR8b9RpJ54,7176
-pypetkitapi/client.py,sha256=6HdTx4Bj8zwHzSzvQz1acdRzGLCX8nETsTeIv-BVc9M,26921
+pypetkitapi/__init__.py,sha256=shPCRXZDzB8-Pofzju8FSV6FKX8m8F_vPfW9woBu_DQ,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=AWkFMNxDOk2CUE0XJLTZZIRDMvBBZTcR1lLKCtKB7jM,22339
+pypetkitapi/media.py,sha256=BW6WHhGGn7hxdZvN27Rcg6vDu4NXB2Q_nTa8arCvacg,25687
 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.2.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
-pypetkitapi-1.10.2.dist-info/METADATA,sha256=OdpyJTrBznYfoFqdoLEYFVJ_Z4QVjaKoZtTiQNdTTmo,6256
-pypetkitapi-1.10.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pypetkitapi-1.10.2.dist-info/RECORD,,
+pypetkitapi-1.11.0.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
+pypetkitapi-1.11.0.dist-info/METADATA,sha256=Xhjy59tO-gmZZodLmf6LDbu0L57IOqFgHL6CdDGfZu4,6256
+pypetkitapi-1.11.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pypetkitapi-1.11.0.dist-info/RECORD,,