pypetkitapi 1.7.9__tar.gz → 1.8.1__tar.gz

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypetkitapi
-Version: 1.7.9
+Version: 1.8.1
 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.18,<2.0.0)
+Requires-Dist: pydantic (>=1.10.18,<3.0.0)
 Description-Content-Type: text/markdown
 
 # Petkit API Client
@@ -66,6 +66,8 @@ pip install pypetkitapi
 ## Usage Example:
 
 ```python
+import asyncio
+import logging
 import aiohttp
 from pypetkitapi.client import PetKitClient
 from pypetkitapi.command import DeviceCommand, FeederCommand, LBCommand, LBAction, LitterCommand

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/README.md

@@ -46,6 +46,8 @@ pip install pypetkitapi
 ## Usage Example:
 
 ```python
+import asyncio
+import logging
 import aiohttp
 from pypetkitapi.client import PetKitClient
 from pypetkitapi.command import DeviceCommand, FeederCommand, LBCommand, LBAction, LitterCommand

pypetkitapi-1.8.1/pypetkitapi/__init__.py

@@ -0,0 +1,86 @@
+"""Pypetkit: A Python library for interfacing with PetKit"""
+
+from .client import PetKitClient
+from .command import (
+    DeviceAction,
+    DeviceCommand,
+    FeederCommand,
+    LBCommand,
+    LitterCommand,
+    PetCommand,
+    PurMode,
+)
+from .const import (
+    CTW3,
+    D3,
+    D4,
+    D4H,
+    D4S,
+    D4SH,
+    DEVICES_FEEDER,
+    DEVICES_LITTER_BOX,
+    DEVICES_PURIFIER,
+    DEVICES_WATER_FOUNTAIN,
+    FEEDER,
+    FEEDER_MINI,
+    K2,
+    K3,
+    T3,
+    T4,
+    T5,
+    T6,
+    W5,
+    RecordType,
+)
+from .containers import Pet
+from .exceptions import PetkitAuthenticationError, PypetkitError
+from .feeder_container import Feeder, RecordsItems
+from .litter_container import Litter, LitterRecord, WorkState
+from .medias import MediaHandler, MediasFiles
+from .purifier_container import Purifier
+from .water_fountain_container import WaterFountain
+
+__version__ = "1.8.1"
+
+__all__ = [
+    "CTW3",
+    "D3",
+    "D4",
+    "D4H",
+    "D4S",
+    "D4SH",
+    "DEVICES_FEEDER",
+    "DEVICES_LITTER_BOX",
+    "DEVICES_PURIFIER",
+    "DEVICES_WATER_FOUNTAIN",
+    "DeviceAction",
+    "DeviceCommand",
+    "FEEDER",
+    "FEEDER_MINI",
+    "Feeder",
+    "FeederCommand",
+    "K2",
+    "K3",
+    "LBCommand",
+    "Litter",
+    "LitterCommand",
+    "LitterRecord",
+    "MediaHandler",
+    "MediasFiles",
+    "Pet",
+    "PetCommand",
+    "PetKitClient",
+    "PetkitAuthenticationError",
+    "PurMode",
+    "Purifier",
+    "PypetkitError",
+    "RecordType",
+    "RecordsItems",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "W5",
+    "WaterFountain",
+    "WorkState",
+]

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/client.py

@@ -17,9 +17,11 @@ from pypetkitapi.const import (
     DEVICE_STATS,
     DEVICES_FEEDER,
     DEVICES_LITTER_BOX,
+    DEVICES_PURIFIER,
     DEVICES_WATER_FOUNTAIN,
     ERR_KEY,
     LOGIN_DATA,
+    PET,
     RES_KEY,
     T4,
     T6,
@@ -40,6 +42,7 @@ from pypetkitapi.exceptions import (
 )
 from pypetkitapi.feeder_container import Feeder, FeederRecord
 from pypetkitapi.litter_container import Litter, LitterRecord, LitterStats, PetOutGraph
+from pypetkitapi.purifier_container import Purifier
 from pypetkitapi.water_fountain_container import WaterFountain, WaterFountainRecord
 
 _LOGGER = logging.getLogger(__name__)
@@ -50,7 +53,7 @@ class PetKitClient:
 
     _session: SessionInfo | None = None
     account_data: list[AccountData] = []
-    petkit_entities: dict[int, Feeder | Litter | WaterFountain | Pet] = {}
+    petkit_entities: dict[int, Feeder | Litter | WaterFountain | Purifier | Pet] = {}
 
     def __init__(
         self,
@@ -75,6 +78,7 @@ class PetKitClient:
     async def _get_base_url(self) -> None:
         """Get the list of API servers, filter by region, and return the matching server."""
         _LOGGER.debug("Getting API server list")
+        self.req.base_url = PetkitDomain.PASSPORT_PETKIT
 
         if self.region.lower() == "china":
             self.req.base_url = PetkitDomain.CHINA_SRV
@@ -126,8 +130,9 @@ class PetKitClient:
             data["validCode"] = valid_code
         else:
             _LOGGER.debug("Login method: using password")
-            pwd = hashlib.md5(self.password.encode()).hexdigest()  # noqa: S324
-            data["password"] = pwd  # noqa: S324
+            data["password"] = hashlib.md5(
+                self.password.encode()
+            ).hexdigest()  # noqa: S324
 
         # Send the login request
         response = await self.req.request(
@@ -149,6 +154,7 @@ class PetKitClient:
         )
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
+        self._session.refreshed_at = datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")
 
     async def validate_session(self) -> None:
         """Check if the session is still valid and refresh or re-login if necessary."""
@@ -195,6 +201,7 @@ class PetKitClient:
             if account.pet_list:
                 for pet in account.pet_list:
                     self.petkit_entities[pet.pet_id] = pet
+                    pet.device_nfo = Device(deviceType=PET, deviceId=pet.pet_id)
 
     async def get_devices_data(self) -> None:
         """Get the devices data from the PetKit servers."""
@@ -217,9 +224,11 @@ class PetKitClient:
 
         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),
@@ -237,6 +246,9 @@ class PetKitClient:
                     self._fetch_device_data(device, WaterFountainRecord)
                 )
 
+            elif device_type in DEVICES_PURIFIER:
+                main_tasks.append(self._fetch_device_data(device, Purifier))
+
         # Execute main device tasks first
         await asyncio.gather(*main_tasks)
 
@@ -264,6 +276,7 @@ class PetKitClient:
             Feeder
             | Litter
             | WaterFountain
+            | Purifier
             | FeederRecord
             | LitterRecord
             | WaterFountainRecord
@@ -309,15 +322,9 @@ 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
-
         if data_class.data_type == DEVICE_DATA:
             self.petkit_entities[device.device_id] = device_data
+            self.petkit_entities[device.device_id].device_nfo = device
             _LOGGER.debug("Device data fetched OK for %s", device_type)
         elif data_class.data_type == DEVICE_RECORDS:
             self.petkit_entities[device.device_id].device_records = device_data
@@ -358,9 +365,12 @@ class PetKitClient:
 
         pets_list = await self.get_pets_list()
         for pet in pets_list:
-            if stats_data.device_type == T4 and stats_data.device_records:
+            if stats_data.device_nfo.device_type == T4 and stats_data.device_records:
                 await self._process_t4(pet, stats_data.device_records)
-            elif stats_data.device_type == T6 and stats_data.device_pet_graph_out:
+            elif (
+                stats_data.device_nfo.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):
@@ -409,15 +419,15 @@ class PetKitClient:
 
         _LOGGER.debug(
             "Control API device=%s id=%s action=%s param=%s",
-            device.device_type,
+            device.device_nfo.device_type,
             device_id,
             action,
             setting,
         )
 
         # Check if the device type is supported
-        if device.device_type:
-            device_type = device.device_type.lower()
+        if device.device_nfo.device_type:
+            device_type = device.device_nfo.device_type.lower()
         else:
             raise PypetkitError(
                 "Device type is not available, and is mandatory for sending commands."
@@ -442,7 +452,7 @@ class PetKitClient:
         else:
             endpoint = action_info.endpoint
             _LOGGER.debug("Endpoint field")
-        url = f"{device.device_type.lower()}/{endpoint}"
+        url = f"{device.device_nfo.device_type.lower()}/{endpoint}"
 
         # Get the parameters
         if setting is not None:

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/command.py

@@ -16,6 +16,8 @@ from pypetkitapi.const import (
     DEVICES_FEEDER,
     FEEDER,
     FEEDER_MINI,
+    K2,
+    K3,
     T3,
     T4,
     T5,
@@ -27,11 +29,13 @@ from pypetkitapi.const import (
 class DeviceCommand(StrEnum):
     """Device Command"""
 
+    POWER = "power_device"
+    CONTROL_DEVICE = "control_device"
     UPDATE_SETTING = "update_setting"
 
 
 class FeederCommand(StrEnum):
-    """Feeder Command"""
+    """Specific Feeder Command"""
 
     CALL_PET = "call_pet"
     CALIBRATION = "food_reset"
@@ -45,25 +49,17 @@ class FeederCommand(StrEnum):
 
 
 class LitterCommand(StrEnum):
-    """LitterCommand"""
+    """Specific LitterCommand"""
 
-    POWER = "power"
-    CONTROL_DEVICE = "control_device"
     RESET_DEODORIZER = "reset_deodorizer"
 
 
 class PetCommand(StrEnum):
-    """PetCommand"""
+    """Specific PetCommand"""
 
     PET_UPDATE_SETTING = "pet_update_setting"
 
 
-class FountainCommand(StrEnum):
-    """Fountain Command"""
-
-    CONTROL_DEVICE = "control_device"
-
-
 class LBCommand(IntEnum):
     """LitterBoxCommand"""
 
@@ -79,14 +75,27 @@ class LBCommand(IntEnum):
     MAINTENANCE = 9
 
 
-class LBAction(StrEnum):
-    """LitterBoxCommandKey"""
+class PurMode(IntEnum):
+    """Purifier working mode"""
+
+    AUTO_MODE = 0
+    SILENT_MODE = 1
+    STANDARD_MODE = 2
+    STRONG_MODE = 3
 
+
+class DeviceAction(StrEnum):
+    """Device action for LitterBox and Purifier"""
+
+    # LitterBox only
     CONTINUE = "continue_action"
     END = "end_action"
-    POWER = "power_action"
     START = "start_action"
     STOP = "stop_action"
+    # Purifier only
+    MODE = "mode_action"
+    # All devices
+    POWER = "power_action"
 
 
 class FountainAction(StrEnum):
@@ -162,6 +171,15 @@ ACTIONS_MAP = {
         },
         supported_device=ALL_DEVICES,
     ),
+    DeviceCommand.CONTROL_DEVICE: CmdData(
+        endpoint=PetkitEndpoint.CONTROL_DEVICE,
+        params=lambda device, command: {
+            "id": device.id,
+            "kv": json.dumps(command),
+            "type": list(command.keys())[0].split("_")[0],
+        },
+        supported_device=[K2, K3, T3, T4, T5, T6],
+    ),
     FeederCommand.REMOVE_DAILY_FEED: CmdData(
         endpoint=PetkitEndpoint.REMOVE_DAILY_FEED,
         params=lambda device, setting: {
@@ -255,15 +273,6 @@ ACTIONS_MAP = {
         },
         supported_device=[D3],
     ),
-    LitterCommand.CONTROL_DEVICE: CmdData(
-        endpoint=PetkitEndpoint.CONTROL_DEVICE,
-        params=lambda device, command: {
-            "id": device.id,
-            "kv": json.dumps(command),
-            "type": list(command.keys())[0].split("_")[0],
-        },
-        supported_device=[T3, T4, T5, T6],
-    ),
     PetCommand.PET_UPDATE_SETTING: CmdData(
         endpoint=PetkitEndpoint.CONTROL_DEVICE,
         params=lambda pet, setting: {

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/const.py

@@ -2,9 +2,6 @@
 
 from enum import StrEnum
 
-MIN_FEED_AMOUNT = 0
-MAX_FEED_AMOUNT = 10
-
 RES_KEY = "result"
 ERR_KEY = "error"
 SUCCESS_KEY = "success"
@@ -29,11 +26,19 @@ T6 = "t6"
 W5 = "w5"
 CTW3 = "ctw3"
 K2 = "k2"
+K3 = "k3"
+PET = "pet"
 
 DEVICES_LITTER_BOX = [T3, T4, T5, T6]
 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]
+DEVICES_PURIFIER = [K2]
+ALL_DEVICES = [
+    *DEVICES_LITTER_BOX,
+    *DEVICES_FEEDER,
+    *DEVICES_WATER_FOUNTAIN,
+    *DEVICES_PURIFIER,
+]
 
 
 class PetkitDomain(StrEnum):
@@ -86,6 +91,18 @@ LOGIN_DATA = {
 }
 
 
+class RecordType(StrEnum):
+    """Record Type constants"""
+
+    EAT = "eat"
+    FEED = "feed"
+    MOVE = "move"
+    PET = "pet"
+
+
+RecordTypeLST = [RecordType.EAT, RecordType.FEED, RecordType.MOVE, RecordType.PET]
+
+
 class PetkitEndpoint(StrEnum):
     """Petkit Endpoint constants"""
 
@@ -119,6 +136,11 @@ class PetkitEndpoint(StrEnum):
     STATISTIC_RELEASE = "statisticRelease"
     GET_PET_OUT_GRAPH = "getPetOutGraph"
 
+    # Video features
+    CLOUD_VIDEO = "cloud/video"
+    GET_DOWNLOAD_M3U8 = "getDownloadM3u8"
+    GET_M3U8 = "getM3u8"
+
     # Feeders
     REPLENISHED_FOOD = "added"
     FRESH_ELEMENT_CALIBRATION = "food_reset"

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/containers.py

@@ -1,6 +1,6 @@
 """Dataclasses container for petkit API."""
 
-from pydantic import BaseModel, Field, root_validator
+from pydantic import BaseModel, Field
 
 
 class RegionInfo(BaseModel):
@@ -43,6 +43,7 @@ class SessionInfo(BaseModel):
     expires_in: int = Field(alias="expiresIn")
     region: str | None = None
     created_at: str = Field(alias="createdAt")
+    refreshed_at: str | None = None
 
 
 class Device(BaseModel):
@@ -50,14 +51,14 @@ class Device(BaseModel):
     Subclass of AccountData.
     """
 
-    created_at: int = Field(alias="createdAt")
-    device_id: int = Field(alias="deviceId")
-    device_name: str = Field(alias="deviceName")
-    device_type: str = Field(alias="deviceType")
-    group_id: int = Field(alias="groupId")
-    type: int
-    type_code: int = Field(alias="typeCode")
-    unique_id: str = Field(alias="uniqueId")
+    created_at: int | None = Field(None, alias="createdAt")
+    device_id: int | None = Field(None, alias="deviceId")
+    device_name: str | None = Field(None, alias="deviceName")
+    device_type: str | None = Field(None, alias="deviceType")
+    group_id: int | None = Field(None, alias="groupId")
+    type: int | None = None
+    type_code: int = Field(0, alias="typeCode")
+    unique_id: str | None = Field(None, alias="uniqueId")
 
 
 class Pet(BaseModel):
@@ -69,25 +70,26 @@ class Pet(BaseModel):
     created_at: int = Field(alias="createdAt")
     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: 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
+    id: int | None = None  # Fictive field copied from id (for HA compatibility)
+    sn: str | None = None  # Fictive field copied from id (for HA compatibility)
+    name: str | None = None  # Fictive field copied from pet_name (for HA compatibility)
+    firmware: str | None = None  # Fictive fixed field (for HA compatibility)
+    device_nfo: Device = Field(default_factory=Device)
 
-    # Got from Litter stats
+    # Litter stats
     last_litter_usage: int = 0
     last_device_used: str | None = None
     last_duration_usage: int = 0
     last_measured_weight: int = 0
 
-    @root_validator(pre=True)
-    def populate_fictive_fields(cls, values):  # noqa: N805
-        """Populate fictive fields based on other fields."""
-        values["id"] = values.get("id") or values.get("petId")
-        values["sn"] = values.get("sn") or values.get("id")
-        values["name"] = values.get("name") or values.get("petName")
-        return values
+    def __init__(self, **data):
+        """Initialize the Pet dataclass.
+        This method is used to fill the fictive fields after the standard initialization.
+        """
+        super().__init__(**data)
+        self.id = self.id or self.pet_id
+        self.sn = self.sn or str(self.id)
+        self.name = self.name or self.pet_name
 
 
 class User(BaseModel):

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/feeder_container.py

@@ -12,12 +12,12 @@ from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
 class FeedItem(BaseModel):
     """Dataclass for feed item data."""
 
-    id: str | None = None
-    name: str | None = None
-    time: int | None = None
     amount: int | None = None
     amount1: int | None = Field(None, alias="amount1")
     amount2: int | None = Field(None, alias="amount2")
+    id: str | None = None
+    name: str | None = None
+    time: int | None = None
 
 
 class FeedDailyList(BaseModel):
@@ -50,9 +50,14 @@ class SettingsFeeder(BaseModel):
     attire_id: int | None = Field(None, alias="attireId")
     attire_switch: int | None = Field(None, alias="attireSwitch")
     auto_product: int | None = Field(None, alias="autoProduct")
+    bucket_name1: str | None = Field(None, alias="bucketName1")
+    bucket_name2: str | None = Field(None, alias="bucketName2")
     camera: int | None = None
     camera_config: int | None = Field(None, alias="cameraConfig")
+    camera_multi_new: list[CameraMultiNew] | None = Field(None, alias="cameraMultiNew")
     camera_multi_range: list | None = Field(None, alias="cameraMultiRange")
+    color_setting: int | None = None
+    conservation: int | None = None
     control_settings: int | None = Field(None, alias="controlSettings")
     desiccant_notify: int | None = Field(None, alias="desiccantNotify")
     detect_config: int | None = Field(None, alias="detectConfig")
@@ -62,8 +67,10 @@ class SettingsFeeder(BaseModel):
     eat_notify: int | None = Field(None, alias="eatNotify")
     eat_sensitivity: int | None = Field(None, alias="eatSensitivity")
     eat_video: int | None = Field(None, alias="eatVideo")
+    factor: int | None = None
     feed_notify: int | None = Field(None, alias="feedNotify")
     feed_picture: int | None = Field(None, alias="feedPicture")
+    feed_sound: int | None = Field(None, alias="feedSound")
     food_notify: int | None = Field(None, alias="foodNotify")
     food_warn: int | None = Field(None, alias="foodWarn")
     food_warn_range: list[int] | None = Field(None, alias="foodWarnRange")
@@ -87,6 +94,7 @@ class SettingsFeeder(BaseModel):
     pet_sensitivity: int | None = Field(None, alias="petSensitivity")
     pre_live: int | None = Field(None, alias="preLive")
     selected_sound: int | None = Field(None, alias="selectedSound")
+    shortest: int | None = None  # D4S
     smart_frame: int | None = Field(None, alias="smartFrame")
     sound_enable: int | None = Field(None, alias="soundEnable")
     surplus: int | None = None  # D3
@@ -99,35 +107,29 @@ class SettingsFeeder(BaseModel):
     tone_multi_range: list[tuple[int, int]] | None = Field(None, alias="toneMultiRange")
     upload: int | None = None
     volume: int | None = None
-    feed_sound: int | None = Field(None, alias="feedSound")
-    factor: int | None = None
-    color_setting: int | None = Field(None, alias="colorSetting")
-    conservation: int | None = None
-    bucket_name1: str | None = Field(None, alias="bucketName1")
-    bucket_name2: str | None = Field(None, alias="bucketName2")
-    camera_multi_new: list[CameraMultiNew] | None = Field(None, alias="cameraMultiNew")
 
 
 class FeedState(BaseModel):
     """Dataclass for feed state data."""
 
+    add_amount_total: int | None = Field(None, alias="addAmountTotal")
+    add_amount_total1: int | None = Field(None, alias="addAmountTotal1")
+    add_amount_total2: int | None = Field(None, alias="addAmountTotal2")
+    eat_amount_total: int | None = Field(None, alias="eatAmountTotal")  # D3
     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 | 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")
-    plan_real_amount_total: int | None = Field(None, alias="planRealAmountTotal")
-    real_amount_total: int | None = Field(None, alias="realAmountTotal")
-    add_amount_total1: int | None = Field(None, alias="addAmountTotal1")
-    add_amount_total2: int | None = Field(None, alias="addAmountTotal2")
     plan_amount_total1: int | None = Field(None, alias="planAmountTotal1")
     plan_amount_total2: int | None = Field(None, alias="planAmountTotal2")
+    plan_real_amount_total: int | None = Field(None, alias="planRealAmountTotal")
     plan_real_amount_total1: int | None = Field(None, alias="planRealAmountTotal1")
     plan_real_amount_total2: int | None = Field(None, alias="planRealAmountTotal2")
+    real_amount_total: int | None = Field(None, alias="realAmountTotal")
     real_amount_total1: int | None = Field(None, alias="realAmountTotal1")
     real_amount_total2: int | None = Field(None, alias="realAmountTotal2")
+    times: int | None = None
 
 
 class StateFeeder(BaseModel):
@@ -135,31 +137,31 @@ 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
+    bowl: int | None = None
     broadcast: dict | None = None
     camera_status: int | None = Field(None, alias="cameraStatus")
     charge: int | None = None
+    conservation_status: int | None = Field(None, alias="conservationStatus")
     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
+    eating: 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")
+    feed_state: FeedState | None = Field(None, alias="feedState")
+    feeding: int | None = None
+    food: int | None = None
+    food1: int | None = Field(None, alias="food1")
+    food2: int | None = Field(None, alias="food2")
     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
-    food1: int | None = Field(None, alias="food1")
-    food2: int | None = Field(None, alias="food2")
-    conservation_status: int | None = Field(None, alias="conservationStatus")
 
 
 class ManualFeed(BaseModel):
@@ -265,6 +267,7 @@ class FeederRecord(BaseModel):
     move: list[RecordsType] | None = None
     pet: list[RecordsType] | None = None
     device_type: str | None = Field(None, alias="deviceType")
+    type_code: int = Field(0, alias="typeCode")
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str | None:
@@ -302,15 +305,19 @@ class Feeder(BaseModel):
     bt_mac: str | None = Field(None, alias="btMac")
     cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")
     created_at: str | None = Field(None, alias="createdAt")
+    device_records: FeederRecord | None = None
     firmware: float
     firmware_details: list[FirmwareDetail] | None = Field(None, alias="firmwareDetails")
     hardware: int
     id: int
     locale: str | None = None
     mac: str | None = None
+    manual_feed: ManualFeed | None = None
     model_code: int | None = Field(None, alias="modelCode")
+    multi_config: bool | None = Field(None, alias="multiConfig")
     multi_feed_item: MultiFeedItem | None = Field(None, alias="multiFeedItem")
     name: str | None = None
+    p2p_type: int | None = Field(None, alias="p2pType")
     secret: str | None = None
     service_status: int | None = Field(None, alias="serviceStatus")
     settings: SettingsFeeder | None = None
@@ -319,11 +326,7 @@ class Feeder(BaseModel):
     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
+    device_nfo: Device | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/litter_container.py

@@ -10,6 +10,7 @@ from pypetkitapi.const import (
     DEVICE_RECORDS,
     DEVICE_STATS,
     T4,
+    T5,
     T6,
     PetkitEndpoint,
 )
@@ -77,7 +78,6 @@ class SettingsLitter(BaseModel):
     pet_detection: int | None = Field(None, alias="petDetection")
     pet_notify: int | None = Field(None, alias="petNotify")
     pre_live: int | None = Field(None, alias="preLive")
-    shortest: int | None = None
     system_sound_enable: int | None = Field(None, alias="systemSoundEnable")
     time_display: int | None = Field(None, alias="timeDisplay")
     toilet_detection: int | None = Field(None, alias="toiletDetection")
@@ -235,14 +235,13 @@ class LitterRecord(BaseModel):
     toilet_detection: int | None = Field(None, alias="toiletDetection")
     upload: int | None = None
     user_id: str | None = Field(None, alias="userId")
-    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."""
         if device_type == T4:
             return PetkitEndpoint.GET_DEVICE_RECORD
-        if device_type == T6:
+        if device_type in [T5, T6]:
             return PetkitEndpoint.GET_DEVICE_RECORD_RELEASE
         raise ValueError(f"Invalid device type: {device_type}")
 
@@ -259,7 +258,7 @@ class LitterRecord(BaseModel):
             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:
+        if device_type in [T5, T6]:
             return {
                 "timestamp": int(datetime.now().timestamp()),
                 "deviceId": device.device_id,
@@ -295,7 +294,6 @@ class LitterStats(BaseModel):
     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:
@@ -359,7 +357,6 @@ class PetOutGraph(BaseModel):
     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:
@@ -382,6 +379,31 @@ class PetOutGraph(BaseModel):
         }
 
 
+class K3Device(BaseModel):
+    """Dataclass for K3 device data."""
+
+    battery: int | None = None
+    created_at: datetime | None = Field(None, alias="createdAt")
+    firmware: int | None = None
+    hardware: int | None = None
+    id: int | None = None
+    lighting: int | None = None
+    liquid: int | None = None
+    liquid_lack: int | None = Field(None, alias="liquidLack")
+    mac: str | None = None
+    name: str | None = None
+    refreshing: int | None = None
+    relate_t4: int | None = Field(None, alias="relateT4")
+    relation: dict | None = None
+    secret: str | None = None
+    settings: dict | None = None
+    sn: str | None = None
+    timezone: float | None = None
+    update_at: datetime | None = Field(None, alias="updateAt")
+    user_id: str | None = Field(None, alias="userId")
+    voltage: int | None = None
+
+
 class Litter(BaseModel):
     """Dataclass for Litter Data.
     Supported devices = T3, T4, T6
@@ -396,6 +418,7 @@ class Litter(BaseModel):
     firmware_details: list[FirmwareDetail] = Field(alias="firmwareDetails")
     hardware: int
     id: int
+    k3_device: K3Device | None = Field(None, alias="k3Device")
     is_pet_out_tips: int | None = Field(None, alias="isPetOutTips")
     locale: str | None = None
     mac: str | None = None
@@ -422,10 +445,10 @@ class Litter(BaseModel):
     service_status: int | None = Field(None, alias="serviceStatus")
     total_time: int | None = Field(None, alias="totalTime")
     with_k3: int | None = Field(None, alias="withK3")
-    device_type: str | None = Field(None, alias="deviceType")
     device_records: list[LitterRecord] | None = None
     device_stats: LitterStats | None = None
     device_pet_graph_out: list[PetOutGraph] | None = None
+    device_nfo: Device | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

pypetkitapi-1.8.1/pypetkitapi/purifier_container.py

@@ -0,0 +1,77 @@
+"""Dataclasses for feeder data."""
+
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field
+
+from pypetkitapi.const import DEVICE_DATA, PetkitEndpoint
+from pypetkitapi.containers import Device, FirmwareDetail, Wifi
+
+
+class Settings(BaseModel):
+    """Dataclass for settings data."""
+
+    auto_work: int | None = Field(None, alias="autoWork")
+    lack_notify: int | None = Field(None, alias="lackNotify")
+    light_mode: int | None = Field(None, alias="lightMode")
+    light_range: list[int] | None = Field(None, alias="lightRange")
+    log_notify: int | None = Field(None, alias="logNotify")
+    manual_lock: int | None = Field(None, alias="manualLock")
+    sound: int | None = None
+    temp_unit: int | None = Field(None, alias="tempUnit")
+
+
+class State(BaseModel):
+    """Dataclass for state data."""
+
+    humidity: int | None = None
+    left_day: int | None = Field(None, alias="leftDay")
+    liquid: int | None = None
+    mode: int | None = None
+    ota: int | None = None
+    overall: int | None = None
+    pim: int | None = None
+    power: int | None = None
+    refresh: float | None = None
+    temp: int | None = None
+    wifi: Wifi | None = None
+
+
+class Purifier(BaseModel):
+    """Dataclass for feeder data."""
+
+    data_type: ClassVar[str] = DEVICE_DATA
+
+    bt_mac: str | None = Field(None, alias="btMac")
+    created_at: str | None = Field(None, alias="createdAt")
+    firmware: str | None = None
+    firmware_details: list[FirmwareDetail] | None = Field(None, alias="firmwareDetails")
+    hardware: int | None = None
+    id: int | None = None
+    locale: str | None = None
+    mac: str | None = None
+    name: str | None = None
+    relation: dict[str, str]
+    secret: str | None = None
+    settings: Settings | None = None
+    share_open: int | None = Field(None, alias="shareOpen")
+    signup_at: str | None = Field(None, alias="signupAt")
+    sn: str | None = None
+    state: State | None = None
+    timezone: float | None = None
+    work_time: list[tuple[int, int]] | None = Field(None, alias="workTime")
+    device_nfo: Device | 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,
+        device: Device,
+        device_data: Any | None = None,
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        return {"id": int(device.device_id)}

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pypetkitapi/water_fountain_container.py

@@ -93,7 +93,6 @@ class WaterFountainRecord(BaseModel):
     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 | None:
@@ -163,8 +162,8 @@ class WaterFountain(BaseModel):
     update_at: str | None = Field(None, alias="updateAt")
     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
+    device_nfo: Device | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

{pypetkitapi-1.7.9 → pypetkitapi-1.8.1}/pyproject.toml

@@ -187,7 +187,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pypetkitapi"
-version = "1.7.9"
+version = "1.8.1"
 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.18"
+pydantic = ">=1.10.18,<3.0.0"
 
 [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.9"
+current_version = "1.8.1"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"
@@ -224,6 +224,9 @@ push = true
     '^version = "{version}"',
     '^current_version = "{version}"',
 ]
+"pypetkitapi/__init__.py" = [
+    '^__version__ = "{version}"',
+]
 
 [tool.tox]
 envlist = ["pre-commit"]

pypetkitapi-1.7.9/pypetkitapi/__init__.py

@@ -1 +0,0 @@
-"""Pypetkit: A Python library for interfacing with PetKit"""