pypetkitapi 1.0.0__tar.gz → 1.2.0__tar.gz

{pypetkitapi-1.0.0 → pypetkitapi-1.2.0}/PKG-INFO

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

{pypetkitapi-1.0.0 → pypetkitapi-1.2.0}/pypetkitapi/client.py

@@ -49,9 +49,6 @@ class PetKitClient:
     _servers_list: list[RegionInfo] = []
     account_data: list[AccountData] = []
     petkit_entities: dict[int, Feeder | Litter | WaterFountain | Pet] = {}
-    petkit_entities_records: dict[
-        int, FeederRecord | LitterRecord | WaterFountainRecord
-    ] = {}
 
     def __init__(
         self,
@@ -67,6 +64,7 @@ class PetKitClient:
         self.region = region.lower()
         self.timezone = timezone
         self._session = None
+        self.petkit_entities = {}
         self.aiohttp_session = session or aiohttp.ClientSession()
         self.req = PrepReq(
             base_url=PetkitDomain.PASSPORT_PETKIT, session=self.aiohttp_session
@@ -84,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", []):
@@ -169,7 +166,6 @@ class PetKitClient:
         elif half_max_age < token_age <= max_age:
             _LOGGER.debug("Token still OK, but refreshing session")
             await self.refresh_session()
-        return
 
     async def get_session_id(self) -> dict:
         """Return the session ID."""
@@ -200,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,
@@ -273,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)
 
@@ -292,18 +297,12 @@ class PetKitClient:
             _LOGGER.error("Unexpected response type: %s", type(response))
             return
 
-        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)
-
         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_records[device_id] = device_data
+            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)
 
@@ -367,7 +366,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")
 
@@ -416,14 +415,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.0.0 → pypetkitapi-1.2.0}/pypetkitapi/const.py

@@ -11,6 +11,7 @@ SUCCESS_KEY = "success"
 
 DEVICE_RECORDS = "deviceRecords"
 DEVICE_DATA = "deviceData"
+PET_DATA = "petData"
 
 # PetKit Models
 FEEDER = "feeder"

{pypetkitapi-1.0.0 → pypetkitapi-1.2.0}/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.0.0 → pypetkitapi-1.2.0}/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.0.0 → pypetkitapi-1.2.0}/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.0.0 → pypetkitapi-1.2.0}/pyproject.toml

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