pypetkitapi 1.4.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

pypetkitapi/containers.py

@@ -1,6 +1,6 @@
 """Dataclasses container for petkit API."""
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 
 class RegionInfo(BaseModel):
@@ -68,8 +68,20 @@ class Pet(BaseModel):
     avatar: str | None = None
     created_at: int = Field(alias="createdAt")
     pet_id: int = Field(alias="petId")
+    id: int | None = None  # Fictive field (for HA compatibility) copied from id
+    sn: int | None = None  # Fictive field (for HA compatibility) copied from id
     pet_name: str | None = Field(None, alias="petName")
-    device_type: str = "pet"
+    name: str | None = None  # Fictive field (for HA compatibility) copied from pet_name
+    device_type: str = "pet"  # Fictive field (for HA compatibility) fixed
+    firmware: str | None = None  # Fictive field (for HA compatibility) fixed
+
+    @model_validator(mode="before")
+    def populate_fictive_fields(cls, values):  # noqa: N805
+        """Populate fictive fields based on other fields."""
+        values["id"] = values.get("id") or values.get("petId")
+        values["sn"] = values.get("sn") or values.get("id")
+        values["name"] = values.get("name") or values.get("petName")
+        return values
 
 
 class User(BaseModel):

pypetkitapi/litter_container.py

@@ -418,7 +418,7 @@ class Litter(BaseModel):
     device_type: str | None = Field(None, alias="deviceType")
     device_records: list[LitterRecord] | None = None
     device_stats: LitterStats | None = None
-    device_pet_graph_out: PetOuGraph | None = None
+    device_pet_graph_out: list[PetOuGraph] | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

pypetkitapi/medias.py

@@ -0,0 +1,198 @@
+"""Module to handle media files from PetKit devices."""
+
+from dataclasses import dataclass
+import logging
+from pathlib import Path
+import re
+
+from aiofiles import open as aio_open
+import aiohttp
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+
+from pypetkitapi.feeder_container import Feeder, RecordsItems
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class MediasFiles:
+    """Dataclass for media files.
+    Subclass of many other device dataclasses.
+    """
+
+    filename: str
+    record_type: str
+    url: str
+    aes_key: str
+
+
+async def extract_filename_from_url(url: str) -> str:
+    """Extract the filename from the URL and format it as requested."""
+    match = re.search(r"https?://[^/]+(/[^?]+)", url)
+    if match:
+        path = match.group(1)
+        formatted_filename = path.replace("/", "_").lstrip("_").lower()
+        return f"{formatted_filename}.jpg"
+    raise ValueError(f"Failed to extract filename from URL: {url}")
+
+
+class MediaHandler:
+    """Class to find media files from PetKit devices."""
+
+    def __init__(self, device: Feeder, file_path: str):
+        """Initialize the class."""
+        self.device = device
+        self.media_download_decode = MediaDownloadDecode(file_path)
+        self.media_files: list[MediasFiles] = []
+
+    async def get_last_image(self) -> list[MediasFiles]:
+        """Process device records and extract media info."""
+        record_types = ["eat", "feed", "move", "pet"]
+        self.media_files = []
+
+        if not self.device.device_records:
+            _LOGGER.error("No device records found for feeder")
+            return []
+
+        for record_type in record_types:
+            records = getattr(self.device.device_records, record_type, None)
+            if records:
+                self.media_files.extend(
+                    await self._process_records(records, record_type)
+                )
+
+        return self.media_files
+
+    async def _process_records(
+        self, records: RecordsItems, record_type: str
+    ) -> list[MediasFiles]:
+        """Process individual records and return media info."""
+        media_files = []
+
+        if record_type == "feed":
+            for record in reversed(records):
+                if record.items:
+                    last_item = next(
+                        (
+                            item
+                            for item in reversed(record.items)
+                            if item.preview and item.aes_key
+                        ),
+                        None,
+                    )
+                    if last_item:
+                        filename = await extract_filename_from_url(last_item.preview)
+                        await self.media_download_decode.get_file(
+                            last_item.preview, last_item.aes_key
+                        )
+                        media_files.append(
+                            MediasFiles(
+                                record_type=record_type,
+                                filename=filename,
+                                url=last_item.preview,
+                                aes_key=last_item.aes_key,
+                            )
+                        )
+                        return media_files
+        else:
+            for record in records:
+                if record.items:
+                    last_item = record.items[-1]
+                    preview_url = last_item.preview
+                    aes_key = last_item.aes_key
+
+                    if preview_url and aes_key:
+                        filename = await extract_filename_from_url(preview_url)
+                        await self.media_download_decode.get_file(preview_url, aes_key)
+                        media_files.append(
+                            MediasFiles(
+                                record_type=record_type,
+                                filename=filename,
+                                url=preview_url,
+                                aes_key=aes_key,
+                            )
+                        )
+        return media_files
+
+
+class MediaDownloadDecode:
+    """Class to download"""
+
+    def __init__(self, download_path: str):
+        """Initialize the class."""
+        self.download_path = download_path
+
+    async def get_file(self, url: str, aes_key: str) -> bool:
+        """Download a file from a URL and decrypt it."""
+        try:
+            # Check if the file already exists
+            filename = await extract_filename_from_url(url)
+            full_file_path = Path(self.download_path) / filename
+            if full_file_path.exists():
+                _LOGGER.debug(
+                    "File already exist : %s don't need to download it", filename
+                )
+                return True
+
+            # Download the file
+            async with aiohttp.ClientSession() as session, session.get(url) as response:
+                if response.status != 200:
+                    _LOGGER.error(
+                        "Failed to download %s, status code: %s", url, response.status
+                    )
+                    return False
+
+                content = await response.read()
+                encrypted_file_path = await self._save_file(content, f"{filename}.enc")
+                # Decrypt the image
+                decrypted_data = await self._decrypt_image_from_file(
+                    encrypted_file_path, aes_key
+                )
+
+                if decrypted_data:
+                    _LOGGER.debug("Decrypt was successful")
+                    await self._save_file(decrypted_data, filename)
+                    Path(encrypted_file_path).unlink()
+                    return True
+                _LOGGER.error("Failed to decrypt %s", encrypted_file_path)
+        except Exception as e:  # noqa: BLE001
+            _LOGGER.error("Error get media file from %s: %s", url, e)
+        return False
+
+    async def _save_file(self, content: bytes, filename: str) -> Path:
+        """Save content to a file asynchronously and return the file path."""
+        file_path = Path(self.download_path) / filename
+        try:
+            async with aio_open(file_path, "wb") as file:
+                await file.write(content)
+            _LOGGER.debug("Saved file: %s", file_path)
+        except OSError as e:
+            _LOGGER.error("Error saving file %s: %s", file_path, e)
+        return file_path
+
+    async def _decrypt_image_from_file(
+        self, file_path: Path, aes_key: str
+    ) -> bytes | None:
+        """Decrypt an image from a file using AES encryption.
+        :param file_path: Path to the encrypted image file.
+        :param aes_key: AES key used for decryption.
+        :return: Decrypted image data.
+        """
+        try:
+            if aes_key.endswith("\n"):
+                aes_key = aes_key[:-1]
+            key_bytes: bytes = aes_key.encode("utf-8")
+            iv: bytes = b"\x61" * 16
+            cipher: AES = AES.new(key_bytes, AES.MODE_CBC, iv)
+
+            async with aio_open(file_path, "rb") as encrypted_file:
+                encrypted_data: bytes = await encrypted_file.read()
+
+            decrypted_data: bytes = unpad(
+                cipher.decrypt(encrypted_data), AES.block_size
+            )
+        except Exception as e:  # noqa: BLE001
+            logging.error("Error decrypting image from file %s: %s", file_path, e)
+            return None
+        return decrypted_data

{pypetkitapi-1.4.0.dist-info → pypetkitapi-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypetkitapi
-Version: 1.4.0
+Version: 1.6.0
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiohttp (>=3.11.0,<4.0.0)
+Requires-Dist: pycryptodome (>=3.21.0,<4.0.0)
 Description-Content-Type: text/markdown
 
 # Petkit API Client

{pypetkitapi-1.4.0.dist-info → pypetkitapi-1.6.0.dist-info}/RECORD

@@ -2,13 +2,14 @@ pypetkitapi/__init__.py,sha256=eVpyGMD3tkYtiHUkdKEeNSZhQlZ4woI2Y5oVoV7CwXM,61
 pypetkitapi/client.py,sha256=iLf1EZRMvuMVwtJ-1PQQ_WT6YjbDDcF--E-5gB7iM44,16716
 pypetkitapi/command.py,sha256=gw3_J_oZHuuGLk66P8uRSqSrySjYa8ArpKaPHi2ybCw,7155
 pypetkitapi/const.py,sha256=9XNLhM9k0GwNmWPgGef5roULpsYVZ7hzxptGgNhjs74,3432
-pypetkitapi/containers.py,sha256=m7vzWcJG0U1EPftuBF6OB8eTVRhCoA2DFqekxI6LozI,3428
+pypetkitapi/containers.py,sha256=zj0MBEYA7wp2Nieu1oW4JROs_r7il9VZN8AUyQv-gJs,4192
 pypetkitapi/exceptions.py,sha256=NWmpsI2ewC4HaIeu_uFwCeuPIHIJxZBzjoCP7aNwvhs,1139
 pypetkitapi/feeder_container.py,sha256=28GXZ8Nbs08PnFZZI4ENBe3UJ63gsXT3rFa151KrPxo,13310
-pypetkitapi/litter_container.py,sha256=oNjg-A_kNbGB3SvRntosaaL-vwLF8fbIKoLwoVm_ejQ,18036
+pypetkitapi/litter_container.py,sha256=UmgIE1iYNFetHjnTXfM6jhRnOk_0Ubdyr697-6SGKqc,18042
+pypetkitapi/medias.py,sha256=2cVgB8eiTxTHCUExPrl2Hon9lg-GLEuqL_Rpay7A4P8,7363
 pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypetkitapi/water_fountain_container.py,sha256=j6FQEgbZAbsPXDVhcIB05RsNnQJftcWUJKmzuX4TrjM,6712
-pypetkitapi-1.4.0.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
-pypetkitapi-1.4.0.dist-info/METADATA,sha256=4kKgKgNKqJ-PvJb1Tfj8dQhNiczRZWbxRMQZESPev0A,4590
-pypetkitapi-1.4.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pypetkitapi-1.4.0.dist-info/RECORD,,
+pypetkitapi-1.6.0.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
+pypetkitapi-1.6.0.dist-info/METADATA,sha256=qxsGx-CErdYdR3YAN4ixrfS4-XtLcu4SAATOxWS8QTM,4636
+pypetkitapi-1.6.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pypetkitapi-1.6.0.dist-info/RECORD,,