pypetkitapi 1.1.0__tar.gz → 1.2.2__tar.gz

{pypetkitapi-1.1.0 → pypetkitapi-1.2.2}/PKG-INFO

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

{pypetkitapi-1.1.0 → pypetkitapi-1.2.2}/pypetkitapi/client.py

@@ -19,7 +19,6 @@ from pypetkitapi.const import (
     DEVICES_WATER_FOUNTAIN,
     ERR_KEY,
     LOGIN_DATA,
-    PET_DATA,
     RES_KEY,
     SUCCESS_KEY,
     Header,
@@ -49,11 +48,7 @@ class PetKitClient:
     _session: SessionInfo | None = None
     _servers_list: list[RegionInfo] = []
     account_data: list[AccountData] = []
-    petkit_entities: dict[
-        str,
-        dict[int, Feeder | Litter | WaterFountain | Pet]
-        | dict[int, FeederRecord | LitterRecord | WaterFountainRecord],
-    ]
+    petkit_entities: dict[int, Feeder | Litter | WaterFountain | Pet] = {}
 
     def __init__(
         self,
@@ -69,7 +64,7 @@ class PetKitClient:
         self.region = region.lower()
         self.timezone = timezone
         self._session = None
-        self.petkit_entities = {DEVICE_RECORDS: {}, DEVICE_DATA: {}, PET_DATA: {}}
+        self.petkit_entities = {}
         self.aiohttp_session = session or aiohttp.ClientSession()
         self.req = PrepReq(
             base_url=PetkitDomain.PASSPORT_PETKIT, session=self.aiohttp_session
@@ -87,7 +82,6 @@ class PetKitClient:
             method=HTTPMethod.GET,
             url=PetkitEndpoint.REGION_SERVERS,
         )
-        _LOGGER.debug("API server list: %s", response)
 
         # Filter the servers by region
         for region in response.get("list", []):
@@ -194,7 +188,7 @@ class PetKitClient:
         for account in self.account_data:
             if account.pet_list:
                 for pet in account.pet_list:
-                    self.petkit_entities[PET_DATA][pet.pet_id] = pet
+                    self.petkit_entities[pet.pet_id] = pet
 
     async def get_devices_data(self) -> None:
         """Get the devices data from the PetKit servers."""
@@ -202,47 +196,54 @@ class PetKitClient:
         if not self.account_data:
             await self._get_account_data()
 
-        tasks = []
+        main_tasks = []
+        record_tasks = []
         device_list: list[Device] = []
 
         for account in self.account_data:
-            _LOGGER.debug("Fetching devices data for account: %s", account)
+            _LOGGER.debug("List devices data for account: %s", account)
             if 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:
-                _LOGGER.debug("Fetching devices data: %s", device)
                 device_type = device.device_type.lower()
-                device_id = device.device_id
                 if device_type in DEVICES_FEEDER:
-                    # Add tasks for feeders
-                    tasks.append(self._fetch_device_data(account, device_id, Feeder))
-                    tasks.append(
-                        self._fetch_device_data(account, device_id, FeederRecord)
+                    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:
-                    # Add tasks for litter boxes
-                    tasks.append(self._fetch_device_data(account, device_id, Litter))
-                    tasks.append(
-                        self._fetch_device_data(account, device_id, LitterRecord)
+                    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:
-                    # Add tasks for water fountains
-                    tasks.append(
-                        self._fetch_device_data(account, device_id, WaterFountain)
+                    main_tasks.append(
+                        self._fetch_device_data(
+                            account, device.device_id, WaterFountain
+                        )
                     )
-                    tasks.append(
-                        self._fetch_device_data(account, device_id, WaterFountainRecord)
+                    record_tasks.append(
+                        self._fetch_device_data(
+                            account, device.device_id, WaterFountainRecord
+                        )
                     )
-                else:
-                    _LOGGER.warning("Unknown device type: %s", device_type)
-        await asyncio.gather(*tasks)
+
+        # Execute main device tasks first
+        await asyncio.gather(*main_tasks)
+
+        # Then execute record tasks
+        await asyncio.gather(*record_tasks)
 
         end_time = datetime.now()
         total_time = end_time - start_time
-        _LOGGER.info("OK Petkit data fetched in : %s", total_time)
+        _LOGGER.info("Petkit data fetched successfully in: %s", total_time)
 
     async def _fetch_device_data(
         self,
@@ -275,6 +276,8 @@ class PetKitClient:
             return
         device_type = device.device_type.lower()
 
+        _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device_id)
+
         endpoint = data_class.get_endpoint(device_type)
         query_param = data_class.query_param(account, device.device_id)
 
@@ -294,15 +297,21 @@ class PetKitClient:
             _LOGGER.error("Unexpected response type: %s", type(response))
             return
 
+        # Add the device type into dataclass
         if isinstance(device_data, list):
             for item in device_data:
                 item.device_type = device_type
         else:
             device_data.device_type = device_type
 
-        _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device_id)
-
-        self.petkit_entities[data_class.data_type][device_id] = device_data
+        if data_class.data_type == DEVICE_DATA:
+            self.petkit_entities[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
+            _LOGGER.debug("Device records fetched OK for %s", device_type)
+        else:
+            _LOGGER.error("Unknown data type: %s", data_class.data_type)
 
     async def send_api_request(
         self,
@@ -311,8 +320,7 @@ class PetKitClient:
         setting: dict | None = None,
     ) -> None:
         """Control the device using the PetKit API."""
-        device_dict = self.petkit_entities.get(DEVICE_DATA, {})
-        device = device_dict.get(device_id)
+        device = self.petkit_entities.get(device_id)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
 
@@ -365,7 +373,7 @@ class PetKitClient:
         )
         if res in (SUCCESS_KEY, RES_KEY):
             # TODO : Manage to get the response from manual feeding
-            _LOGGER.info("Command executed successfully")
+            _LOGGER.debug("Command executed successfully")
         else:
             _LOGGER.error("Command execution failed")
 
@@ -414,14 +422,7 @@ class PrepReq:
         """Make a request to the PetKit API."""
         _url = "/".join(s.strip("/") for s in [self.base_url, url])
         _headers = {**self.base_headers, **(headers or {})}
-        _LOGGER.debug(
-            "Request: %s %s Params: %s Data: %s Headers: %s",
-            method,
-            _url,
-            params,
-            data,
-            _headers,
-        )
+        _LOGGER.debug("Request: %s %s", method, _url)
         try:
             async with self.session.request(
                 method,

{pypetkitapi-1.1.0 → pypetkitapi-1.2.2}/pypetkitapi/feeder_container.py

@@ -167,48 +167,6 @@ class ManualFeed(BaseModel):
     time: int | None = None
 
 
-class Feeder(BaseModel):
-    """Dataclass for feeder data."""
-
-    data_type: ClassVar[str] = DEVICE_DATA
-
-    auto_upgrade: int | None = Field(None, alias="autoUpgrade")
-    bt_mac: str | None = Field(None, alias="btMac")
-    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")
-    hardware: int
-    id: int
-    locale: str | None = None
-    mac: str | None = None
-    model_code: int | None = Field(None, alias="modelCode")
-    multi_feed_item: MultiFeedItem | None = Field(None, alias="multiFeedItem")
-    name: str | None = None
-    secret: str | None = None
-    service_status: int | None = Field(None, alias="serviceStatus")
-    settings: SettingsFeeder | None = None
-    share_open: int | None = Field(None, alias="shareOpen")
-    signup_at: str | None = Field(None, alias="signupAt")
-    sn: str
-    state: StateFeeder | None = None
-    timezone: float | None = None
-    p2p_type: int | None = Field(None, alias="p2pType")
-    multi_config: bool | None = Field(None, alias="multiConfig")
-    device_type: str | None = Field(None, alias="deviceType")
-    manual_feed: ManualFeed | None = None
-
-    @classmethod
-    def get_endpoint(cls, device_type: str) -> str:
-        """Get the endpoint URL for the given device type."""
-        return PetkitEndpoint.DEVICE_DETAIL
-
-    @classmethod
-    def query_param(cls, account: AccountData, device_id: int) -> dict:
-        """Generate query parameters including request_date."""
-        return {"id": device_id}
-
-
 class EventState(BaseModel):
     """Dataclass for event state data."""
 
@@ -300,3 +258,46 @@ class FeederRecord(BaseModel):
         if request_date is None:
             request_date = datetime.now().strftime("%Y%m%d")
         return {"days": int(request_date), "deviceId": device_id}
+
+
+class Feeder(BaseModel):
+    """Dataclass for feeder data."""
+
+    data_type: ClassVar[str] = DEVICE_DATA
+
+    auto_upgrade: int | None = Field(None, alias="autoUpgrade")
+    bt_mac: str | None = Field(None, alias="btMac")
+    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")
+    hardware: int
+    id: int
+    locale: str | None = None
+    mac: str | None = None
+    model_code: int | None = Field(None, alias="modelCode")
+    multi_feed_item: MultiFeedItem | None = Field(None, alias="multiFeedItem")
+    name: str | None = None
+    secret: str | None = None
+    service_status: int | None = Field(None, alias="serviceStatus")
+    settings: SettingsFeeder | None = None
+    share_open: int | None = Field(None, alias="shareOpen")
+    signup_at: str | None = Field(None, alias="signupAt")
+    sn: str
+    state: StateFeeder | None = None
+    timezone: float | None = None
+    p2p_type: int | None = Field(None, alias="p2pType")
+    multi_config: bool | None = Field(None, alias="multiConfig")
+    device_type: str | None = Field(None, alias="deviceType")
+    manual_feed: ManualFeed | None = None
+    device_records: FeederRecord | None = None
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.DEVICE_DETAIL
+
+    @classmethod
+    def query_param(cls, account: AccountData, device_id: int) -> dict:
+        """Generate query parameters including request_date."""
+        return {"id": device_id}

{pypetkitapi-1.1.0 → pypetkitapi-1.2.2}/pypetkitapi/litter_container.py

@@ -142,58 +142,6 @@ class StateLitter(BaseModel):
     work_state: WorkState | None = Field(None, alias="workState")
 
 
-class Litter(BaseModel):
-    """Dataclass for Litter Data.
-    Supported devices = T4, T6
-    """
-
-    data_type: ClassVar[str] = DEVICE_DATA
-
-    auto_upgrade: int | None = Field(None, alias="autoUpgrade")
-    bt_mac: str | None = Field(None, alias="btMac")
-    created_at: str | None = Field(None, alias="createdAt")
-    firmware: float
-    firmware_details: list[FirmwareDetail] = Field(alias="firmwareDetails")
-    hardware: int
-    id: int
-    is_pet_out_tips: int | None = Field(None, alias="isPetOutTips")
-    locale: str | None = None
-    mac: str | None = None
-    maintenance_time: int | None = Field(None, alias="maintenanceTime")
-    multi_config: bool | None = Field(None, alias="multiConfig")
-    name: str | None = None
-    pet_in_tip_limit: int | None = Field(None, alias="petInTipLimit")
-    pet_out_tips: list[Any] | None = Field(None, alias="petOutTips")
-    secret: str | None = None
-    settings: SettingsLitter | None = None
-    share_open: int | None = Field(None, alias="shareOpen")
-    signup_at: str | None = Field(None, alias="signupAt")
-    sn: str
-    state: StateLitter | None = None
-    timezone: float | None = None
-    cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")  # For T5/T6
-    in_times: int | None = Field(None, alias="inTimes")
-    last_out_time: int | None = Field(None, alias="lastOutTime")
-    p2p_type: int | None = Field(None, alias="p2pType")
-    package_ignore_state: int | None = Field(None, alias="packageIgnoreState")
-    package_total_count: int | None = Field(None, alias="packageTotalCount")
-    package_used_count: int | None = Field(None, alias="packageUsedCount")
-    pet_out_records: list[list[int]] | None = Field(None, alias="petOutRecords")
-    service_status: int | None = Field(None, alias="serviceStatus")
-    total_time: int | None = Field(None, alias="totalTime")
-    device_type: str | None = Field(None, alias="deviceType")
-
-    @classmethod
-    def get_endpoint(cls, device_type: str) -> str:
-        """Get the endpoint URL for the given device type."""
-        return PetkitEndpoint.DEVICE_DETAIL
-
-    @classmethod
-    def query_param(cls, account: AccountData, device_id: int) -> dict:
-        """Generate query parameters including request_date."""
-        return {"id": device_id}
-
-
 class Content(BaseModel):
     """Dataclass for content data."""
 
@@ -247,3 +195,56 @@ class LitterRecord(BaseModel):
         if request_date is None:
             request_date = datetime.now().strftime("%Y%m%d")
         return {"date": int(request_date), "deviceId": device_id}
+
+
+class Litter(BaseModel):
+    """Dataclass for Litter Data.
+    Supported devices = T4, T6
+    """
+
+    data_type: ClassVar[str] = DEVICE_DATA
+
+    auto_upgrade: int | None = Field(None, alias="autoUpgrade")
+    bt_mac: str | None = Field(None, alias="btMac")
+    created_at: str | None = Field(None, alias="createdAt")
+    firmware: float
+    firmware_details: list[FirmwareDetail] = Field(alias="firmwareDetails")
+    hardware: int
+    id: int
+    is_pet_out_tips: int | None = Field(None, alias="isPetOutTips")
+    locale: str | None = None
+    mac: str | None = None
+    maintenance_time: int | None = Field(None, alias="maintenanceTime")
+    multi_config: bool | None = Field(None, alias="multiConfig")
+    name: str | None = None
+    pet_in_tip_limit: int | None = Field(None, alias="petInTipLimit")
+    pet_out_tips: list[Any] | None = Field(None, alias="petOutTips")
+    secret: str | None = None
+    settings: SettingsLitter | None = None
+    share_open: int | None = Field(None, alias="shareOpen")
+    signup_at: str | None = Field(None, alias="signupAt")
+    sn: str
+    state: StateLitter | None = None
+    timezone: float | None = None
+    cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")  # For T5/T6
+    in_times: int | None = Field(None, alias="inTimes")
+    last_out_time: int | None = Field(None, alias="lastOutTime")
+    p2p_type: int | None = Field(None, alias="p2pType")
+    package_ignore_state: int | None = Field(None, alias="packageIgnoreState")
+    package_total_count: int | None = Field(None, alias="packageTotalCount")
+    package_used_count: int | None = Field(None, alias="packageUsedCount")
+    pet_out_records: list[list[int]] | None = Field(None, alias="petOutRecords")
+    service_status: int | None = Field(None, alias="serviceStatus")
+    total_time: int | None = Field(None, alias="totalTime")
+    device_type: str | None = Field(None, alias="deviceType")
+    device_records: LitterRecord | None = None
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.DEVICE_DETAIL
+
+    @classmethod
+    def query_param(cls, account: AccountData, device_id: int) -> dict:
+        """Generate query parameters including request_date."""
+        return {"id": device_id}

{pypetkitapi-1.1.0 → pypetkitapi-1.2.2}/pypetkitapi/water_fountain_container.py

@@ -85,6 +85,38 @@ class Status(BaseModel):
     suspend_status: int | None = Field(None, alias="suspendStatus")
 
 
+class WaterFountainRecord(BaseModel):
+    """Dataclass for feeder record data."""
+
+    data_type: ClassVar[str] = DEVICE_RECORDS
+
+    day_time: int | None = Field(None, alias="dayTime")
+    stay_time: int | None = Field(None, alias="stayTime")
+    work_time: int | None = Field(None, alias="workTime")
+    device_type: str | None = Field(None, alias="deviceType")
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.GET_WORK_RECORD
+
+    @classmethod
+    def query_param(
+        cls, account: AccountData, device_id: int, 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")
+        return {
+            "day": int(request_date),
+            "deviceId": device_id,
+            "userId": account.user_list[0].user_id,
+        }
+
+
 class WaterFountain(BaseModel):
     """Dataclass for Water Fountain Data.
     Supported devices = CTW3
@@ -128,6 +160,7 @@ class WaterFountain(BaseModel):
     user_id: str | None = Field(None, alias="userId")
     water_pump_run_time: int | None = Field(None, alias="waterPumpRunTime")
     device_type: str | None = Field(None, alias="deviceType")
+    device_records: list[WaterFountainRecord] | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
@@ -138,35 +171,3 @@ class WaterFountain(BaseModel):
     def query_param(cls, account: AccountData, device_id: int) -> dict:
         """Generate query parameters including request_date."""
         return {"id": device_id}
-
-
-class WaterFountainRecord(BaseModel):
-    """Dataclass for feeder record data."""
-
-    data_type: ClassVar[str] = DEVICE_RECORDS
-
-    day_time: int | None = Field(None, alias="dayTime")
-    stay_time: int | None = Field(None, alias="stayTime")
-    work_time: int | None = Field(None, alias="workTime")
-    device_type: str | None = Field(None, alias="deviceType")
-
-    @classmethod
-    def get_endpoint(cls, device_type: str) -> str:
-        """Get the endpoint URL for the given device type."""
-        return PetkitEndpoint.GET_WORK_RECORD
-
-    @classmethod
-    def query_param(
-        cls, account: AccountData, device_id: int, 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")
-        return {
-            "day": int(request_date),
-            "deviceId": device_id,
-            "userId": account.user_list[0].user_id,
-        }

{pypetkitapi-1.1.0 → pypetkitapi-1.2.2}/pyproject.toml

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.1.0"
+version = "1.2.2"
 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.1.0"
+current_version = "1.2.2"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"