pypetkitapi 1.7.4__tar.gz → 1.7.7__tar.gz

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypetkitapi
-Version: 1.7.4
+Version: 1.7.7
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
@@ -15,7 +15,7 @@ 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: pycryptodome (>=3.19.1,<4.0.0)
-Requires-Dist: pydantic (>=1.10.19,<2.0.0)
+Requires-Dist: pydantic (>=1.10.18,<2.0.0)
 Description-Content-Type: text/markdown
 
 # Petkit API Client

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/client.py

@@ -30,9 +30,11 @@ from pypetkitapi.const import (
 from pypetkitapi.containers import AccountData, Device, Pet, RegionInfo, SessionInfo
 from pypetkitapi.exceptions import (
     PetkitAuthenticationError,
+    PetkitAuthenticationUnregisteredEmailError,
     PetkitInvalidHTTPResponseCodeError,
     PetkitInvalidResponseFormat,
     PetkitRegionalServerNotFoundError,
+    PetkitSessionExpiredError,
     PetkitTimeoutError,
     PypetkitError,
 )
@@ -87,6 +89,7 @@ class PetKitClient:
         for region in response.get("list", []):
             server = RegionInfo(**region)
             if server.name.lower() == self.region or server.id.lower() == self.region:
+                self.region = server.id.lower()
                 self.req.base_url = server.gateway
                 _LOGGER.debug("Found matching server: %s", server)
                 return
@@ -206,6 +209,7 @@ class PetKitClient:
             if account.device_list:
                 _LOGGER.debug("Devices in account: %s", account.device_list)
                 device_list.extend(account.device_list)
+                _LOGGER.debug("Found %s devices", len(account.device_list))
 
         for device in device_list:
             device_type = device.device_type.lower()
@@ -259,6 +263,8 @@ class PetKitClient:
             | FeederRecord
             | LitterRecord
             | WaterFountainRecord
+            | PetOutGraph
+            | LitterStats
         ],
     ) -> None:
         """Fetch the device data from the PetKit servers."""
@@ -345,16 +351,14 @@ class PetKitClient:
             return 0
         return end - start
 
-    async def populate_pet_stats(self, stats_data: Litter | None) -> None:
+    async def populate_pet_stats(self, stats_data: Litter) -> None:
         """Collect data from litter data to populate pet stats."""
-        if stats_data is None:
-            return
 
         pets_list = await self.get_pets_list()
         for pet in pets_list:
-            if stats_data.device_records:
+            if stats_data.device_type == T4 and stats_data.device_records:
                 await self._process_t4(pet, stats_data.device_records)
-            elif stats_data.device_pet_graph_out:
+            elif stats_data.device_type == T6 and stats_data.device_pet_graph_out:
                 await self._process_t6(pet, stats_data.device_pet_graph_out)
 
     async def _process_t4(self, pet, device_records):
@@ -528,17 +532,24 @@ class PrepReq:
 
         # Check for errors in the response
         if ERR_KEY in response_json:
+            error_code = int(response_json[ERR_KEY].get("code", 0))
             error_msg = response_json[ERR_KEY].get("msg", "Unknown error")
-            if any(
-                endpoint in url
-                for endpoint in [
-                    PetkitEndpoint.LOGIN,
-                    PetkitEndpoint.GET_LOGIN_CODE,
-                    PetkitEndpoint.REFRESH_SESSION,
-                ]
-            ):
-                raise PetkitAuthenticationError(f"Login failed: {error_msg}")
-            raise PypetkitError(f"Request failed: {error_msg}")
+
+            match error_code:
+                case 5:
+                    raise PetkitSessionExpiredError(f"Session expired: {error_msg}")
+                case 122:
+                    raise PetkitAuthenticationError(
+                        f"Authentication failed: {error_msg}"
+                    )
+                case 125:
+                    raise PetkitAuthenticationUnregisteredEmailError(
+                        f"Authentication failed: {error_msg}"
+                    )
+                case _:
+                    raise PypetkitError(
+                        f"Request failed code : {error_code} details : {error_msg}"
+                    )
 
         # Check for success in the response
         if RES_KEY in response_json:

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/const.py

@@ -31,7 +31,7 @@ CTW3 = "ctw3"
 K2 = "k2"
 
 DEVICES_LITTER_BOX = [T3, T4, T5, T6]
-DEVICES_FEEDER = [FEEDER, FEEDER_MINI, D4, D4S, D4H, D4SH]
+DEVICES_FEEDER = [FEEDER, FEEDER_MINI, D3, D4, D4S, D4H, D4SH]
 DEVICES_WATER_FOUNTAIN = [W5, CTW3]
 ALL_DEVICES = [*DEVICES_LITTER_BOX, *DEVICES_FEEDER, *DEVICES_WATER_FOUNTAIN]
 
@@ -131,3 +131,5 @@ class PetkitEndpoint(StrEnum):
     MANUAL_FEED_MINI = "feedermini/save_dailyfeed"
     MANUAL_FEED_FRESH_ELEMENT = "feeder/save_dailyfeed"
     MANUAL_FEED_DUAL = "saveDailyFeed"
+    DAILY_FEED_AND_EAT = "dailyFeedAndEat"  # D3
+    FEED_STATISTIC = "feedStatistic"  # D4

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/containers.py

@@ -70,7 +70,7 @@ class Pet(BaseModel):
     pet_id: int = Field(alias="petId")
     pet_name: str | None = Field(None, alias="petName")
     id: int | None = None  # Fictive field (for HA compatibility) copied from id
-    sn: int | None = None  # Fictive field (for HA compatibility) copied from id
+    sn: str  # Fictive field (for HA compatibility) copied from id
     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

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/exceptions.py

@@ -11,10 +11,14 @@ class PetkitTimeoutError(PypetkitError):
     """Class for PyPetkit timeout exceptions."""
 
 
-class PetkitConnectionError(PypetkitError):
+class PetkitSessionExpiredError(PypetkitError):
     """Class for PyPetkit connection exceptions."""
 
 
+class PetkitAuthenticationUnregisteredEmailError(PypetkitError):
+    """Exception raised when the email is not registered with Petkit."""
+
+
 class PetkitRegionalServerNotFoundError(PypetkitError):
     """Exception raised when the specified region server is not found."""
 

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/feeder_container.py

@@ -5,7 +5,7 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field
 
-from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
+from pypetkitapi.const import D3, D4, DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
 from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
 
 
@@ -89,6 +89,7 @@ class SettingsFeeder(BaseModel):
     selected_sound: int | None = Field(None, alias="selectedSound")
     smart_frame: int | None = Field(None, alias="smartFrame")
     sound_enable: int | None = Field(None, alias="soundEnable")
+    surplus: int | None = None  # D3
     surplus_control: int | None = Field(None, alias="surplusControl")
     surplus_standard: int | None = Field(None, alias="surplusStandard")
     system_sound_enable: int | None = Field(None, alias="systemSoundEnable")
@@ -113,7 +114,7 @@ class FeedState(BaseModel):
     eat_avg: int | None = Field(None, alias="eatAvg")
     eat_count: int | None = Field(None, alias="eatCount")
     eat_times: list[int] | None = Field(None, alias="eatTimes")
-    feed_times: dict | None = Field(None, alias="feedTimes")
+    feed_times: dict | list | None = Field(None, alias="feedTimes")
     times: int | None = None
     add_amount_total: int | None = Field(None, alias="addAmountTotal")
     plan_amount_total: int | None = Field(None, alias="planAmountTotal")
@@ -135,17 +136,24 @@ class StateFeeder(BaseModel):
     battery_power: int | None = Field(None, alias="batteryPower")
     battery_status: int | None = Field(None, alias="batteryStatus")
     bowl: int | None = None
+    block: int | None = None
+    broadcast: dict | None = None
     camera_status: int | None = Field(None, alias="cameraStatus")
+    charge: int | None = None
     desiccant_left_days: int | None = Field(None, alias="desiccantLeftDays")
     desiccant_time: int | None = Field(None, alias="desiccantTime")
     door: int | None = None
     feed_state: FeedState | None = Field(None, alias="feedState")
     feeding: int | None = None
+    error_code: str | None = Field(None, alias="errorCode")
+    error_detail: str | None = Field(None, alias="errorDetail")
+    error_level: int | None = Field(None, alias="errorLevel")
     error_msg: str | None = Field(None, alias="errorMsg")
     ota: int | None = None
     overall: int | None = None
     pim: int | None = None
     runtime: int | None = None
+    weight: int | None = None
     wifi: Wifi | None = None
     eating: int | None = None
     food: int | None = None
@@ -198,6 +206,7 @@ class RecordsItems(BaseModel):
     eat_end_time: int | None = Field(None, alias="eatEndTime")
     eat_start_time: int | None = Field(None, alias="eatStartTime")
     eat_video: int | None = Field(None, alias="eatVideo")
+    eat_weight: int | None = Field(None, alias="eatWeight")  # D3
     empty: int | None = None
     end_time: int | None = Field(None, alias="endTime")
     enum_event_type: str | None = Field(None, alias="enumEventType")
@@ -210,10 +219,12 @@ class RecordsItems(BaseModel):
     id: str | None = None
     is_executed: int | None = Field(None, alias="isExecuted")
     is_need_upload_video: int | None = Field(None, alias="isNeedUploadVideo")
+    left_weight: int | None = Field(None, alias="leftWeight")  # D3
     mark: int | None = None
     media_api: str | None = Field(None, alias="mediaApi")
     media_list: list[Any] | None = Field(None, alias="mediaList")
     name: str | None = None
+    pet_id: str | None = Field(None, alias="petId")
     preview: str | None = None
     preview1: str | None = Field(None, alias="preview1")
     preview2: str | None = Field(None, alias="preview2")
@@ -235,11 +246,13 @@ class RecordsType(BaseModel):
     day: int | None = None
     device_id: int | None = Field(None, alias="deviceId")
     eat_count: int | None = Field(None, alias="eatCount")
+    eat_amount: int | None = Field(None, alias="eatAmount")  # D3
     items: list[RecordsItems] | None = None
     plan_amount: int | None = Field(None, alias="planAmount")
     real_amount: int | None = Field(None, alias="realAmount")
     amount: int | None = None
     times: int | None = None
+    user_id: str | None = Field(None, alias="userId")  # D3
 
 
 class FeederRecord(BaseModel):
@@ -254,8 +267,12 @@ class FeederRecord(BaseModel):
     device_type: str | None = Field(None, alias="deviceType")
 
     @classmethod
-    def get_endpoint(cls, device_type: str) -> str:
+    def get_endpoint(cls, device_type: str) -> str | None:
         """Get the endpoint URL for the given device type."""
+        if device_type == D3:
+            return PetkitEndpoint.DAILY_FEED_AND_EAT
+        if device_type == D4:
+            return PetkitEndpoint.FEED_STATISTIC
         return PetkitEndpoint.GET_DEVICE_RECORD
 
     @classmethod
@@ -268,7 +285,10 @@ class FeederRecord(BaseModel):
         """Generate query parameters including request_date."""
         if request_date is None:
             request_date = datetime.now().strftime("%Y%m%d")
-        return {"days": int(request_date), "deviceId": device.device_id}
+
+        if device.device_type.lower() == D4:
+            return {"date": request_date, "type": 0, "deviceId": device.device_id}
+        return {"days": request_date, "deviceId": device.device_id}
 
 
 class Feeder(BaseModel):
@@ -281,7 +301,7 @@ class Feeder(BaseModel):
     cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")
     created_at: str | None = Field(None, alias="createdAt")
     firmware: float
-    firmware_details: list[FirmwareDetail] = Field(alias="firmwareDetails")
+    firmware_details: list[FirmwareDetail] | None = Field(None, alias="firmwareDetails")
     hardware: int
     id: int
     locale: str | None = None

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/litter_container.py

@@ -109,6 +109,9 @@ class StateLitter(BaseModel):
     box_full: bool | None = Field(None, alias="boxFull")
     box_state: int | None = Field(None, alias="boxState")
     deodorant_left_days: int | None = Field(None, alias="deodorantLeftDays")
+    error_code: str | None = Field(None, alias="errorCode")
+    error_detail: str | None = Field(None, alias="errorDetail")
+    error_level: int | None = Field(None, alias="errorLevel")
     error_msg: str | None = Field(None, alias="errorMsg")
     frequent_restroom: int | None = Field(None, alias="frequentRestroom")
     liquid_empty: bool | None = Field(None, alias="liquidEmpty")

{pypetkitapi-1.7.4 → pypetkitapi-1.7.7}/pypetkitapi/medias.py

@@ -41,28 +41,30 @@ async def extract_filename_from_url(url: str) -> str:
 class MediaHandler:
     """Class to find media files from PetKit devices."""
 
-    def __init__(self, device: Feeder, file_path: str):
+    def __init__(self, file_path: Path):
         """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]:
+    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 self.device.device_records:
+        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(self.device.device_records, record_type, None)
+            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(
@@ -111,45 +113,39 @@ class MediaHandler:
 class MediaDownloadDecode:
     """Class to download"""
 
-    def __init__(self, download_path: str):
+    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."""
-        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
+        # 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 True
+                return False
 
-            # 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()
 
-                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
-                )
+        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)
+        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:
@@ -198,4 +194,6 @@ class MediaDownloadDecode:
         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.7.4 → pypetkitapi-1.7.7}/pyproject.toml

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.7.4"
+version = "1.7.7"
 description = "Python client for PetKit API"
 authors = ["Jezza34000 <info@mail.com>"]
 readme = "README.md"
@@ -199,7 +199,7 @@ python = ">=3.11"
 aiohttp = "^3.10.10"
 aiofiles = "^24.1.0"
 pycryptodome = "^3.19.1"
-pydantic = "^1.10.19"
+pydantic = "^1.10.18"
 
 [tool.poetry.dev-dependencies]
 pre-commit = "^4.0.1"
@@ -208,7 +208,7 @@ ruff = "^0.8.1"
 types-aiofiles = "^24.1.0.20240626"
 
 [tool.bumpver]
-current_version = "1.7.4"
+current_version = "1.7.7"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"