pypetkitapi 1.9.3__py3-none-any.whl → 1.10.1__py3-none-any.whl

pypetkitapi/schedule_container.py

@@ -0,0 +1,67 @@
+"""Dataclasses for Schedule."""
+
+from datetime import datetime
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field
+
+from pypetkitapi.const import DEVICE_DATA, PetkitEndpoint
+from pypetkitapi.containers import Device
+
+
+class Owner(BaseModel):
+    """Dataclass for Owner Data."""
+
+    device_count: int | None = Field(0, alias="deviceCount")
+    id: str | None = None
+    pet_count: int | None = Field(0, alias="petCount")
+    user_count: int | None = Field(0, alias="userCount")
+
+
+class Type(BaseModel):
+    """Dataclass for Type Data."""
+
+    enable: int | None = None
+    id: str | None = None
+    img: str | None = None
+    is_custom: int | None = Field(0, alias="isCustom")
+    name: str | None = None
+    priority: int | None = None
+    repeat_option: str | None = Field(alias="repeatOption")
+    rpt: str | None = None
+    schedule_appoint: str | None = Field(alias="scheduleAppoint")
+    with_device_type: str | None = Field(alias="withDeviceType")
+    with_pet: int | None = Field(0, alias="withPet")
+
+
+class Schedule(BaseModel):
+    """Dataclass for Schedule Data."""
+
+    data_type: ClassVar[str] = DEVICE_DATA
+
+    alarm_before: int | None = Field(0, alias="alarmBefore")
+    created_at: datetime | None = Field(None, alias="createdAt")
+    device_id: str | None = Field(None, alias="deviceId")
+    device_type: str | None = Field(None, alias="deviceType")
+    id: str | None = None
+    name: str | None = None
+    owner: Owner | None = None
+    repeat: str | None = None
+    status: int | None = None
+    time: datetime | None = None
+    type: Type | None = None
+    user_custom_id: int | None = Field(0, alias="userCustomId")
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.SCHEDULE
+
+    @classmethod
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        return {"limit": 20}

{pypetkitapi-1.9.3.dist-info → pypetkitapi-1.10.1.dist-info}/METADATA

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.9.3
+Version: 1.10.1
 Summary: Python client for PetKit API
-Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
 Author: Jezza34000
 Author-email: info@mail.com
@@ -14,8 +13,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: aiohttp (>=3.10.10,<4.0.0)
+Requires-Dist: m3u8 (>=6.0)
 Requires-Dist: pycryptodome (>=3.19.1,<4.0.0)
 Requires-Dist: pydantic (>=1.10.18,<3.0.0)
+Project-URL: Homepage, https://github.com/Jezza34000/pypetkit
 Description-Content-Type: text/markdown
 
 # Petkit API Client
@@ -110,7 +111,9 @@ async def main():
         # simple hopper :
         await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount": 1})
         # dual hopper :
-        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED_DUAL, {"amount1": 2})
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount1": 2})
+        # or
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount2": 2})
 
         ### Example 3 : Start the cleaning process
         ### Device_ID, Command, Payload

pypetkitapi-1.10.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+pypetkitapi/__init__.py,sha256=8Y70aqpRJgFqcA64OlYIxp0f6gLGpsXWuSpi69TXXN8,2107
+pypetkitapi/bluetooth.py,sha256=u_xGp701WnrroTOt_KuIVUCZ3kRQ7BJeoMR8b9RpJ54,7176
+pypetkitapi/client.py,sha256=6HdTx4Bj8zwHzSzvQz1acdRzGLCX8nETsTeIv-BVc9M,26921
+pypetkitapi/command.py,sha256=cMCUutZCQo9Ddvjl_FYR5UjU_CqFz1iyetMznYwjpzM,7500
+pypetkitapi/const.py,sha256=US5QihmBYvlm8hIHX0PORPUnMmDW3nmLzwLWTepkkGg,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=0HrBjxylkMzxDyLWoReMaLAGRBh1YIJsifGhXzB54hA,19275
+pypetkitapi/media.py,sha256=31fjIznqfIRpmdObJPYNSwSa95fYmRQnqxEs9Wq5gcM,22116
+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.1.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
+pypetkitapi-1.10.1.dist-info/METADATA,sha256=kzPqa6ZgyoZaVsgYL5aroM0h12mmBzXVz0ZxqWwSKjs,6256
+pypetkitapi-1.10.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pypetkitapi-1.10.1.dist-info/RECORD,,

{pypetkitapi-1.9.3.dist-info → pypetkitapi-1.10.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.0
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

pypetkitapi/medias.py

@@ -1,199 +0,0 @@
-"""Module to handle media files from PetKit devices."""
-
-from dataclasses import dataclass
-import logging
-from pathlib import Path
-import re
-from typing import Any
-
-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, RecordsType
-
-_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
-    timestamp: str | None = None
-
-
-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, file_path: Path):
-        """Initialize the class."""
-        self.media_download_decode = MediaDownloadDecode(file_path)
-        self.media_files: list[MediasFiles] = []
-
-    async def get_last_image(self, device: Feeder) -> list[MediasFiles]:
-        """Process device records and extract media info."""
-        record_types = ["eat", "feed", "move", "pet"]
-        self.media_files = []
-
-        if not isinstance(device, Feeder):
-            _LOGGER.error("Device is not a Feeder")
-            return []
-
-        if not device.device_records:
-            _LOGGER.error("No device records found for feeder")
-            return []
-
-        for record_type in record_types:
-            records = getattr(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: RecordsType, record_type: str
-    ) -> list[MediasFiles]:
-        """Process individual records and return media info."""
-        media_files = []
-
-        async def process_item(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
-                )
-                timestamp = (
-                    last_item.eat_start_time
-                    or last_item.completed_at
-                    or last_item.timestamp
-                    or None
-                )
-                media_files.append(
-                    MediasFiles(
-                        record_type=record_type,
-                        filename=filename,
-                        url=last_item.preview,
-                        aes_key=last_item.aes_key,
-                        timestamp=timestamp,
-                    )
-                )
-
-        for record in records:
-            if hasattr(record, "items"):
-                await process_item(record.items)  # type: ignore[attr-defined]
-
-        return media_files
-
-
-class MediaDownloadDecode:
-    """Class to download"""
-
-    def __init__(self, download_path: Path):
-        """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."""
-        # 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)
-            return True
-        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:
-            # Ensure the directory exists
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-
-            async with aio_open(file_path, "wb") as file:
-                await file.write(content)
-            _LOGGER.debug("Save file OK : %s", file_path)
-        except PermissionError as e:
-            _LOGGER.error("Save file, permission denied %s: %s", file_path, e)
-        except FileNotFoundError as e:
-            _LOGGER.error("Save file, file/folder not found %s: %s", file_path, e)
-        except OSError as e:
-            _LOGGER.error("Save file, error saving file %s: %s", file_path, e)
-        except Exception as e:  # noqa: BLE001
-            _LOGGER.error(
-                "Save file, unexpected error saving file %s: %s", file_path, e
-            )
-        return file_path
-
-    @staticmethod
-    async def _decrypt_image_from_file(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: 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 = unpad(
-                cipher.decrypt(encrypted_data), AES.block_size  # type: ignore[attr-defined]
-            )
-        except Exception as e:  # noqa: BLE001
-            logging.error("Error decrypting image from file %s: %s", file_path, e)
-            return None
-        if Path(file_path).exists():
-            Path(file_path).unlink()
-        return decrypted_data

pypetkitapi-1.9.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-pypetkitapi/__init__.py,sha256=dQiuXe1aOwEGmW27csDtKRVc4vhXrqvsW-0ElcbrTRY,1562
-pypetkitapi/client.py,sha256=oi1GhGIcvWMP5J9ueN2Y1xDX-Wm91b7LfjTVSe_plk4,30357
-pypetkitapi/command.py,sha256=G7AEtUcaK-lcRliNf4oUxPkvDO_GNBkJ-ZUcOo7DGHM,7697
-pypetkitapi/const.py,sha256=xDsF6sdxqQPy0B0Qhpe0Nn5xrkDjfo_omL4XL_oXFDE,4050
-pypetkitapi/containers.py,sha256=oJR22ZruMr-0IRgiucdnj_nutOH59MKvmaFTwLJNiJI,4635
-pypetkitapi/exceptions.py,sha256=fuTLT6Iw2_kA7eOyNJPf59vQkgfByhAnTThY4lC0Rt0,1283
-pypetkitapi/feeder_container.py,sha256=ZGJhgqP-gjTFB2q91XoyZQ_G1S5cAY37JoqqHbzoanU,14640
-pypetkitapi/litter_container.py,sha256=-z2BtdtRg8RyLJzJYY3AIACs9GGZ0C64hVhW4do6yQo,19172
-pypetkitapi/medias.py,sha256=ZFdiPj24crYYFwKBUqlxKhfKGrW2uXoXzDl2vWukZ-A,7036
-pypetkitapi/purifier_container.py,sha256=ssyIxhNben5XJ4KlQTXTrtULg2ji6DqHqjzOq08d1-I,2491
-pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypetkitapi/utils.py,sha256=z7325kcJQUburnF28HSXrJMvY_gY9007K73Zwxp-4DQ,743
-pypetkitapi/water_fountain_container.py,sha256=5J0b-fDZYcFLNX2El7fifv8H6JMhBCt-ttxSow1ozRQ,6787
-pypetkitapi-1.9.3.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
-pypetkitapi-1.9.3.dist-info/METADATA,sha256=p0SF9NMmun43lj81I0Sbc24o7JwFhuQgHoOK4tTquC8,6115
-pypetkitapi-1.9.3.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-pypetkitapi-1.9.3.dist-info/RECORD,,