pypetkitapi 1.2.4__tar.gz → 1.3.0__tar.gz

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypetkitapi
-Version: 1.2.4
+Version: 1.3.0
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/pypetkitapi/client.py

@@ -14,6 +14,7 @@ from pypetkitapi.command import ACTIONS_MAP
 from pypetkitapi.const import (
     DEVICE_DATA,
     DEVICE_RECORDS,
+    DEVICE_STATS,
     DEVICES_FEEDER,
     DEVICES_LITTER_BOX,
     DEVICES_WATER_FOUNTAIN,
@@ -21,6 +22,8 @@ from pypetkitapi.const import (
     LOGIN_DATA,
     RES_KEY,
     SUCCESS_KEY,
+    T4,
+    T6,
     Header,
     PetkitDomain,
     PetkitEndpoint,
@@ -35,7 +38,7 @@ from pypetkitapi.exceptions import (
     PypetkitError,
 )
 from pypetkitapi.feeder_container import Feeder, FeederRecord
-from pypetkitapi.litter_container import Litter, LitterRecord
+from pypetkitapi.litter_container import Litter, LitterRecord, LitterStats, PetOuGraph
 from pypetkitapi.water_fountain_container import WaterFountain, WaterFountainRecord
 
 _LOGGER = logging.getLogger(__name__)
@@ -201,37 +204,30 @@ class PetKitClient:
         for account in self.account_data:
             _LOGGER.debug("List devices data for account: %s", account)
             if account.device_list:
+                _LOGGER.debug("Devices in account: %s", account.device_list)
                 device_list.extend(account.device_list)
 
-            _LOGGER.debug("Fetch %s devices for this account", len(device_list))
-
-            for device in device_list:
-                device_type = device.device_type.lower()
-                if device_type in DEVICES_FEEDER:
-                    main_tasks.append(
-                        self._fetch_device_data(account, device.device_id, Feeder)
-                    )
-                    record_tasks.append(
-                        self._fetch_device_data(account, device.device_id, FeederRecord)
-                    )
-                elif device_type in DEVICES_LITTER_BOX:
-                    main_tasks.append(
-                        self._fetch_device_data(account, device.device_id, Litter)
-                    )
-                    record_tasks.append(
-                        self._fetch_device_data(account, device.device_id, LitterRecord)
-                    )
-                elif device_type in DEVICES_WATER_FOUNTAIN:
-                    main_tasks.append(
-                        self._fetch_device_data(
-                            account, device.device_id, WaterFountain
-                        )
-                    )
-                    record_tasks.append(
-                        self._fetch_device_data(
-                            account, device.device_id, WaterFountainRecord
-                        )
-                    )
+        for device in device_list:
+            device_type = device.device_type.lower()
+            if device_type in DEVICES_FEEDER:
+                main_tasks.append(self._fetch_device_data(device, Feeder))
+                record_tasks.append(self._fetch_device_data(device, FeederRecord))
+            elif device_type in DEVICES_LITTER_BOX:
+                main_tasks.append(
+                    self._fetch_device_data(device, Litter),
+                )
+                record_tasks.append(self._fetch_device_data(device, LitterRecord))
+
+                if device_type == T4:
+                    record_tasks.append(self._fetch_device_data(device, LitterStats))
+                if device_type == T6:
+                    record_tasks.append(self._fetch_device_data(device, PetOuGraph))
+
+            elif device_type in DEVICES_WATER_FOUNTAIN:
+                main_tasks.append(self._fetch_device_data(device, WaterFountain))
+                record_tasks.append(
+                    self._fetch_device_data(device, WaterFountainRecord)
+                )
 
         # Execute main device tasks first
         await asyncio.gather(*main_tasks)
@@ -241,12 +237,11 @@ class PetKitClient:
 
         end_time = datetime.now()
         total_time = end_time - start_time
-        _LOGGER.info("Petkit data fetched successfully in: %s", total_time)
+        _LOGGER.debug("Petkit data fetched successfully in: %s", total_time)
 
     async def _fetch_device_data(
         self,
-        account: AccountData,
-        device_id: int,
+        device: Device,
         data_class: type[
             Feeder
             | Litter
@@ -258,26 +253,19 @@ class PetKitClient:
     ) -> None:
         """Fetch the device data from the PetKit servers."""
         await self.validate_session()
-        device = None
-
-        if account.device_list:
-            device = next(
-                (
-                    device
-                    for device in account.device_list
-                    if device.device_id == device_id
-                ),
-                None,
-            )
-        if device is None:
-            _LOGGER.error("Device not found: id=%s", device_id)
-            return
+
         device_type = device.device_type.lower()
 
-        _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device_id)
+        _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device.device_id)
 
         endpoint = data_class.get_endpoint(device_type)
-        query_param = data_class.query_param(account, device.device_id)
+
+        # Specific device ask for data from the device
+        device_cont = None
+        if self.petkit_entities.get(device.device_id, None):
+            device_cont = self.petkit_entities[device.device_id]
+
+        query_param = data_class.query_param(device, device_cont)
 
         response = await self.req.request(
             method=HTTPMethod.POST,
@@ -286,6 +274,10 @@ class PetKitClient:
             headers=await self.get_session_id(),
         )
 
+        # Workaround for the litter box T6
+        if isinstance(response, dict) and response.get("list", None):
+            response = response.get("list", [])
+
         # Check if the response is a list or a dict
         if isinstance(response, list):
             device_data = [data_class(**item) for item in response]
@@ -303,11 +295,19 @@ class PetKitClient:
             device_data.device_type = device_type
 
         if data_class.data_type == DEVICE_DATA:
-            self.petkit_entities[device_id] = device_data
+            self.petkit_entities[device.device_id] = device_data
             _LOGGER.debug("Device data fetched OK for %s", device_type)
         elif data_class.data_type == DEVICE_RECORDS:
-            self.petkit_entities[device_id].device_records = device_data
+            self.petkit_entities[device.device_id].device_records = device_data
             _LOGGER.debug("Device records fetched OK for %s", device_type)
+        elif data_class.data_type == DEVICE_STATS:
+            if device_type == T4:
+                self.petkit_entities[device.device_id].device_stats = device_data
+            if device_type == T6:
+                self.petkit_entities[device.device_id].device_pet_graph_out = (
+                    device_data
+                )
+            _LOGGER.debug("Device stats fetched OK for %s", device_type)
         else:
             _LOGGER.error("Unknown data type: %s", data_class.data_type)
 
@@ -316,7 +316,7 @@ class PetKitClient:
         device_id: int,
         action: StrEnum,
         setting: dict | None = None,
-    ) -> None:
+    ) -> bool:
         """Control the device using the PetKit API."""
         device = self.petkit_entities.get(device_id)
         if not device:
@@ -345,9 +345,11 @@ class PetKitClient:
         _LOGGER.debug(action)
         _LOGGER.debug(action_info)
         if device_type not in action_info.supported_device:
-            raise PypetkitError(
-                f"Device type {device.device_type} not supported for action {action}."
+            _LOGGER.error(
+                "Device type %s not supported for action %s.", device_type, action
             )
+            return False
+
         # Get the endpoint
         if callable(action_info.endpoint):
             endpoint = action_info.endpoint(device)
@@ -369,11 +371,12 @@ class PetKitClient:
             data=params,
             headers=await self.get_session_id(),
         )
-        if res in (SUCCESS_KEY, RES_KEY):
-            # TODO : Manage to get the response from manual feeding
+
+        if res in [RES_KEY, SUCCESS_KEY]:
             _LOGGER.debug("Command executed successfully")
-        else:
-            _LOGGER.error("Command execution failed")
+            return True
+        _LOGGER.error("Command execution failed")
+        return False
 
     async def close(self) -> None:
         """Close the aiohttp session if it was created by the client."""

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/pypetkitapi/const.py

@@ -11,6 +11,7 @@ SUCCESS_KEY = "success"
 
 DEVICE_RECORDS = "deviceRecords"
 DEVICE_DATA = "deviceData"
+DEVICE_STATS = "deviceStats"
 PET_DATA = "petData"
 
 # PetKit Models
@@ -114,6 +115,9 @@ class PetkitEndpoint(StrEnum):
 
     # Litter Box
     DEODORANT_RESET = "deodorantReset"
+    STATISTIC = "statistic"
+    STATISTIC_RELEASE = "statisticRelease"
+    GET_PET_OUT_GRAPH = "getPetOutGraph"
 
     # Feeders
     REPLENISHED_FOOD = "added"

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/pypetkitapi/feeder_container.py

@@ -6,7 +6,7 @@ from typing import Any, ClassVar
 from pydantic import BaseModel, Field
 
 from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
-from pypetkitapi.containers import AccountData, CloudProduct, FirmwareDetail, Wifi
+from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
 
 
 class FeedItem(BaseModel):
@@ -157,6 +157,7 @@ class StateFeeder(BaseModel):
 class ManualFeed(BaseModel):
     """Dataclass for result data."""
 
+    amount: int | None = None
     amount1: int | None = None
     amount2: int | None = None
     id: str | None = None
@@ -259,12 +260,15 @@ class FeederRecord(BaseModel):
 
     @classmethod
     def query_param(
-        cls, account: AccountData, device_id: int, request_date: str | None = None
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+        request_date: str | None = None,
     ) -> dict:
         """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_id}
+        return {"days": int(request_date), "deviceId": device.device_id}
 
 
 class Feeder(BaseModel):
@@ -305,6 +309,10 @@ class Feeder(BaseModel):
         return PetkitEndpoint.DEVICE_DETAIL
 
     @classmethod
-    def query_param(cls, account: AccountData, device_id: int) -> dict:
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+    ) -> dict:
         """Generate query parameters including request_date."""
-        return {"id": device_id}
+        return {"id": int(device.device_id)}

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/pypetkitapi/litter_container.py

@@ -5,8 +5,15 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field
 
-from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
-from pypetkitapi.containers import AccountData, CloudProduct, FirmwareDetail, Wifi
+from pypetkitapi.const import (
+    DEVICE_DATA,
+    DEVICE_RECORDS,
+    DEVICE_STATS,
+    T4,
+    T6,
+    PetkitEndpoint,
+)
+from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
 
 
 class SettingsLitter(BaseModel):
@@ -194,7 +201,9 @@ class LRSubContent(BaseModel):
 
 
 class LitterRecord(BaseModel):
-    """Dataclass for feeder record data."""
+    """Dataclass for feeder record data.
+    Litter records
+    """
 
     data_type: ClassVar[str] = DEVICE_RECORDS
 
@@ -226,21 +235,149 @@ class LitterRecord(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        return PetkitEndpoint.GET_DEVICE_RECORD
+        if device_type == T4:
+            return PetkitEndpoint.GET_DEVICE_RECORD
+        if device_type == T6:
+            return PetkitEndpoint.GET_DEVICE_RECORD_RELEASE
+        raise ValueError(f"Invalid device type: {device_type}")
+
+    @classmethod
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+        request_date: str | None = None,
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        device_type = device.device_type.lower()
+        if device_type == T4:
+            if request_date is None:
+                request_date = datetime.now().strftime("%Y%m%d")
+            return {"date": int(request_date), "deviceId": device.device_id}
+        if device_type == T6:
+            return {
+                "timestamp": int(datetime.now().timestamp()),
+                "deviceId": device.device_id,
+                "type": 2,
+            }
+        raise ValueError(f"Invalid device type: {device_type}")
+
+
+class StatisticInfo(BaseModel):
+    """Dataclass for statistic information.
+    Subclass of LitterStats.
+    """
+
+    pet_id: str | None = Field(None, alias="petId")
+    pet_name: str | None = Field(None, alias="petName")
+    pet_times: int | None = Field(None, alias="petTimes")
+    pet_total_time: int | None = Field(None, alias="petTotalTime")
+    pet_weight: int | None = Field(None, alias="petWeight")
+    statistic_date: str | None = Field(None, alias="statisticDate")
+    x_time: int | None = Field(None, alias="xTime")
+
+
+class LitterStats(BaseModel):
+    """Dataclass for result data.
+    Supported devices = T4 only (T3 ?)
+    """
+
+    data_type: ClassVar[str] = DEVICE_STATS
+
+    avg_time: int | None = Field(None, alias="avgTime")
+    pet_ids: list[dict] | None = Field(None, alias="petIds")
+    statistic_info: list[StatisticInfo] | None = Field(None, alias="statisticInfo")
+    statistic_time: str | None = Field(None, alias="statisticTime")
+    times: int | None = None
+    total_time: int | None = Field(None, alias="totalTime")
+    device_type: str | None = None
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.STATISTIC
+
+    @classmethod
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> dict:
+        """Generate query parameters including request_date."""
+
+        if start_date is None and end_date is None:
+            start_date = datetime.now().strftime("%Y%m%d")
+            end_date = datetime.now().strftime("%Y%m%d")
+
+        return {
+            "endDate": end_date,
+            "deviceId": device.device_id,
+            "type": 0,
+            "startDate": start_date,
+        }
+
+
+class PetGraphContent(BaseModel):
+    """Dataclass for content data."""
+
+    auto_clear: int | None = Field(None, alias="autoClear")
+    img: str | None = None
+    interval: int | None = None
+    is_shit: int | None = Field(None, alias="isShit")
+    mark: int | None = None
+    media: int | None = None
+    pet_weight: int | None = Field(None, alias="petWeight")
+    shit_weight: int | None = Field(None, alias="shitWeight")
+    time_in: int | None = Field(None, alias="timeIn")
+    time_out: int | None = Field(None, alias="timeOut")
+
+
+class PetOuGraph(BaseModel):
+    """Dataclass for event data."""
+
+    data_type: ClassVar[str] = DEVICE_STATS
+
+    aes_key: str | None = Field(None, alias="aesKey")
+    content: PetGraphContent | None = None
+    duration: int | None = None
+    event_id: str | None = Field(None, alias="eventId")
+    expire: int | None = None
+    is_need_upload_video: int | None = Field(None, alias="isNeedUploadVideo")
+    media_api: str | None = Field(None, alias="mediaApi")
+    pet_id: str | None = Field(None, alias="petId")
+    pet_name: str | None = Field(None, alias="petName")
+    preview: str | None = None
+    storage_space: int | None = Field(None, alias="storageSpace")
+    time: int | None = None
+    toilet_time: int | None = Field(None, alias="toiletTime")
+    device_type: str | None = None
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.GET_PET_OUT_GRAPH
 
     @classmethod
     def query_param(
-        cls, account: AccountData, device_id: int, request_date: str | None = None
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
     ) -> dict:
         """Generate query parameters including request_date."""
-        if request_date is None:
-            request_date = datetime.now().strftime("%Y%m%d")
-        return {"date": int(request_date), "deviceId": device_id}
+
+        return {
+            "timestamp": int(datetime.now().timestamp()),
+            "deviceId": device.device_id,
+        }
 
 
 class Litter(BaseModel):
     """Dataclass for Litter Data.
-    Supported devices = T4, T6
+    Supported devices = T3, T4, T6
     """
 
     data_type: ClassVar[str] = DEVICE_DATA
@@ -279,6 +416,8 @@ class Litter(BaseModel):
     total_time: int | None = Field(None, alias="totalTime")
     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
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
@@ -286,6 +425,10 @@ class Litter(BaseModel):
         return PetkitEndpoint.DEVICE_DETAIL
 
     @classmethod
-    def query_param(cls, account: AccountData, device_id: int) -> dict:
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+    ) -> dict:
         """Generate query parameters including request_date."""
-        return {"id": device_id}
+        return {"id": device.device_id}

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/pypetkitapi/water_fountain_container.py

@@ -6,7 +6,7 @@ from typing import Any, ClassVar
 from pydantic import BaseModel, Field
 
 from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
-from pypetkitapi.containers import AccountData
+from pypetkitapi.containers import Device
 
 
 class Electricity(BaseModel):
@@ -102,18 +102,20 @@ class WaterFountainRecord(BaseModel):
 
     @classmethod
     def query_param(
-        cls, account: AccountData, device_id: int, request_date: str | None = None
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+        request_date: str | None = None,
     ) -> dict:
         """Generate query parameters including request_date."""
-        if not account.user_list or not account.user_list[0]:
-            raise ValueError("The account does not have a valid user_list.")
-
         if request_date is None:
             request_date = datetime.now().strftime("%Y%m%d")
+        if device_data is None or not hasattr(device_data, "user_id"):
+            raise ValueError("The device_data does not have a valid user_id.")
         return {
             "day": int(request_date),
-            "deviceId": device_id,
-            "userId": account.user_list[0].user_id,
+            "deviceId": device.device_id,
+            "userId": device_data.user_id,
         }
 
 
@@ -168,6 +170,10 @@ class WaterFountain(BaseModel):
         return PetkitEndpoint.DEVICE_DATA
 
     @classmethod
-    def query_param(cls, account: AccountData, device_id: int) -> dict:
+    def query_param(
+        cls,
+        device: Device,
+        device_data: Any | None = None,
+    ) -> dict:
         """Generate query parameters including request_date."""
-        return {"id": device_id}
+        return {"id": device.device_id}

{pypetkitapi-1.2.4 → pypetkitapi-1.3.0}/pyproject.toml

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.2.4"
+version = "1.3.0"
 description = "Python client for PetKit API"
 authors = ["Jezza34000 <info@mail.com>"]
 readme = "README.md"
@@ -204,7 +204,7 @@ black = "^24.10.0"
 ruff = "^0.8.1"
 
 [tool.bumpver]
-current_version = "1.2.4"
+current_version = "1.3.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"