pypetkitapi 1.7.10__py3-none-any.whl → 1.9.0__py3-none-any.whl

pypetkitapi/__init__.py

@@ -1,15 +1,25 @@
 """Pypetkit: A Python library for interfacing with PetKit"""
 
 from .client import PetKitClient
-from .command import FeederCommand, LBAction, LBCommand, LitterCommand, PetCommand
+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,
@@ -22,35 +32,55 @@ from .const import (
     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.7.10"
+__version__ = "1.9.0"
 
 __all__ = [
-    "MediasFiles",
-    "MediaHandler",
+    "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",
-    "CTW3",
-    "K2",
-    "K3",
-    "DEVICES_FEEDER",
-    "DEVICES_LITTER_BOX",
-    "DEVICES_WATER_FOUNTAIN",
-    "RecordType",
-    "PetKitClient",
-    "FeederCommand",
-    "LitterCommand",
-    "PetCommand",
-    "LBCommand",
-    "LBAction",
+    "WaterFountain",
+    "WorkState",
 ]

pypetkitapi/client.py

@@ -1,25 +1,32 @@
 """Pypetkit Client: A Python library for interfacing with PetKit"""
 
 import asyncio
+import base64
 from datetime import datetime, timedelta
 from enum import StrEnum
 import hashlib
 from http import HTTPMethod
 import logging
+import urllib.parse
 
 import aiohttp
 from aiohttp import ContentTypeError
 
-from pypetkitapi.command import ACTIONS_MAP
+from pypetkitapi.command import ACTIONS_MAP, FOUNTAIN_COMMAND, FountainAction
 from pypetkitapi.const import (
+    BLE_CONNECT_ATTEMPT,
+    BLE_END_TRAME,
+    BLE_START_TRAME,
     DEVICE_DATA,
     DEVICE_RECORDS,
     DEVICE_STATS,
     DEVICES_FEEDER,
     DEVICES_LITTER_BOX,
+    DEVICES_PURIFIER,
     DEVICES_WATER_FOUNTAIN,
     ERR_KEY,
     LOGIN_DATA,
+    PET,
     RES_KEY,
     T4,
     T6,
@@ -27,7 +34,14 @@ from pypetkitapi.const import (
     PetkitDomain,
     PetkitEndpoint,
 )
-from pypetkitapi.containers import AccountData, Device, Pet, RegionInfo, SessionInfo
+from pypetkitapi.containers import (
+    AccountData,
+    BleRelay,
+    Device,
+    Pet,
+    RegionInfo,
+    SessionInfo,
+)
 from pypetkitapi.exceptions import (
     PetkitAuthenticationError,
     PetkitAuthenticationUnregisteredEmailError,
@@ -40,6 +54,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 +65,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 +90,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 +142,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 +166,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 +213,16 @@ 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,
+                        createdAt=pet.created_at,
+                        deviceName=pet.pet_name,
+                        groupId=0,
+                        type=0,
+                        typeCode=0,
+                        uniqueId=pet.sn,
+                    )
 
     async def get_devices_data(self) -> None:
         """Get the devices data from the PetKit servers."""
@@ -216,10 +244,12 @@ class PetKitClient:
                 _LOGGER.debug("Found %s devices", len(account.device_list))
 
         for device in device_list:
-            device_type = device.device_type.lower()
+            device_type = device.device_type
+
             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 +267,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)
 
@@ -247,7 +280,7 @@ class PetKitClient:
         stats_tasks = [
             self.populate_pet_stats(self.petkit_entities[device.device_id])
             for device in device_list
-            if device.device_type.lower() in DEVICES_LITTER_BOX
+            if device.device_type in DEVICES_LITTER_BOX
         ]
 
         # Execute stats tasks
@@ -264,6 +297,7 @@ class PetKitClient:
             Feeder
             | Litter
             | WaterFountain
+            | Purifier
             | FeederRecord
             | LitterRecord
             | WaterFountainRecord
@@ -272,7 +306,7 @@ class PetKitClient:
         ],
     ) -> None:
         """Fetch the device data from the PetKit servers."""
-        device_type = device.device_type.lower()
+        device_type = device.device_type
 
         _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device.device_id)
 
@@ -309,15 +343,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 +386,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):
@@ -394,6 +425,171 @@ class PetKitClient:
                 pet.last_duration_usage = self.get_safe_value(graph.toilet_time)
                 pet.last_device_used = "Purobot Ultra"
 
+    async def _get_fountain_instance(self, fountain_id: int) -> WaterFountain:
+        # Retrieve the water fountain object
+        water_fountain = self.petkit_entities.get(fountain_id)
+        if not water_fountain:
+            _LOGGER.error("Water fountain with ID %s not found.", fountain_id)
+            raise ValueError(f"Water fountain with ID {fountain_id} not found.")
+        return water_fountain
+
+    async def check_relay_availability(self, fountain_id: int) -> bool:
+        """Check if BLE relay is available for the account."""
+        fountain = None
+        for account in self.account_data:
+            fountain = next(
+                (
+                    device
+                    for device in account.device_list
+                    if device.device_id == fountain_id
+                ),
+                None,
+            )
+            if fountain:
+                break
+
+        if not fountain:
+            raise ValueError(
+                f"Fountain with device_id {fountain_id} not found for the current account"
+            )
+
+        group_id = fountain.group_id
+
+        response = await self.req.request(
+            method=HTTPMethod.POST,
+            url=f"{PetkitEndpoint.BLE_AS_RELAY}",
+            params={"groupId": group_id},
+            headers=await self.get_session_id(),
+        )
+        ble_relays = [BleRelay(**relay) for relay in response]
+
+        if len(ble_relays) == 0:
+            _LOGGER.warning("No BLE relay devices found.")
+            return False
+        return True
+
+    async def open_ble_connection(self, fountain_id: int) -> bool:
+        """Open a BLE connection to a PetKit device."""
+        _LOGGER.info("Opening BLE connection to fountain %s", fountain_id)
+        water_fountain = await self._get_fountain_instance(fountain_id)
+
+        if await self.check_relay_availability(fountain_id) is False:
+            _LOGGER.error("BLE relay not available.")
+            return False
+
+        if water_fountain.is_connected is True:
+            _LOGGER.error("BLE connection already established.")
+            return True
+
+        response = await self.req.request(
+            method=HTTPMethod.POST,
+            url=PetkitEndpoint.BLE_CONNECT,
+            data={
+                "bleId": fountain_id,
+                "type": 24,
+                "mac": water_fountain.mac,
+            },
+            headers=await self.get_session_id(),
+        )
+        if response != {"state": 1}:
+            _LOGGER.error("Failed to establish BLE connection.")
+            water_fountain.is_connected = False
+            return False
+
+        for attempt in range(BLE_CONNECT_ATTEMPT):
+            _LOGGER.warning("BLE connection attempt n%s", attempt)
+            response = await self.req.request(
+                method=HTTPMethod.POST,
+                url=PetkitEndpoint.BLE_POLL,
+                data={
+                    "bleId": fountain_id,
+                    "type": 24,
+                    "mac": water_fountain.mac,
+                },
+                headers=await self.get_session_id(),
+            )
+            if response == 1:
+                _LOGGER.info("BLE connection established successfully.")
+                water_fountain.is_connected = True
+                water_fountain.last_ble_poll = datetime.now().strftime(
+                    "%Y-%m-%dT%H:%M:%S.%f"
+                )
+                return True
+            await asyncio.sleep(4)
+        _LOGGER.error("Failed to establish BLE connection after multiple attempts.")
+        water_fountain.is_connected = False
+        return False
+
+    async def close_ble_connection(self, fountain_id: int) -> None:
+        """Close the BLE connection to a PetKit device."""
+        _LOGGER.info("Closing BLE connection to fountain %s", fountain_id)
+        water_fountain = await self._get_fountain_instance(fountain_id)
+
+        await self.req.request(
+            method=HTTPMethod.POST,
+            url=PetkitEndpoint.BLE_CANCEL,
+            data={
+                "bleId": fountain_id,
+                "type": 24,
+                "mac": water_fountain.mac,
+            },
+            headers=await self.get_session_id(),
+        )
+        _LOGGER.info("BLE connection closed successfully.")
+
+    async def get_ble_cmd_data(
+        self, fountain_command: list, counter: int
+    ) -> tuple[int, str]:
+        """Prepare BLE data by adding start and end trame to the command and extracting the first number."""
+        cmd_code = fountain_command[0]
+        modified_command = fountain_command[:2] + [counter] + fountain_command[2:]
+        ble_data = [*BLE_START_TRAME, *modified_command, *BLE_END_TRAME]
+        encoded_data = await self._encode_ble_data(ble_data)
+        return cmd_code, encoded_data
+
+    @staticmethod
+    async def _encode_ble_data(byte_list: list) -> str:
+        """Encode a list of bytes to a URL encoded base64 string."""
+        byte_array = bytearray(byte_list)
+        b64_encoded = base64.b64encode(byte_array)
+        return urllib.parse.quote(b64_encoded)
+
+    async def send_ble_command(self, fountain_id: int, command: FountainAction) -> bool:
+        """BLE command to a PetKit device."""
+        _LOGGER.info("Sending BLE command to fountain %s", fountain_id)
+        water_fountain = await self._get_fountain_instance(fountain_id)
+
+        if water_fountain.is_connected is False:
+            _LOGGER.error("BLE connection not established.")
+            return False
+
+        command = FOUNTAIN_COMMAND.get[command, None]
+        if command is None:
+            _LOGGER.error("Command not found.")
+            return False
+
+        cmd_code, cmd_data = await self.get_ble_cmd_data(
+            command, water_fountain.ble_counter
+        )
+
+        response = await self.req.request(
+            method=HTTPMethod.POST,
+            url=PetkitEndpoint.BLE_CONTROL_DEVICE,
+            data={
+                "bleId": water_fountain.id,
+                "cmd": cmd_code,
+                "data": cmd_data,
+                "mac": water_fountain.mac,
+                "type": 24,
+            },
+            headers=await self.get_session_id(),
+        )
+        if response != 1:
+            _LOGGER.error("Failed to send BLE command.")
+            return False
+        _LOGGER.info("BLE command sent successfully.")
+        return True
+
     async def send_api_request(
         self,
         device_id: int,
@@ -403,21 +599,21 @@ class PetKitClient:
         """Control the device using the PetKit API."""
         await self.validate_session()
 
-        device = self.petkit_entities.get(device_id)
+        device = self.petkit_entities.get(device_id, None)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
 
         _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
         else:
             raise PypetkitError(
                 "Device type is not available, and is mandatory for sending commands."
@@ -442,7 +638,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}/{endpoint}"
 
         # Get the parameters
         if setting is not None:

pypetkitapi/command.py

@@ -16,6 +16,8 @@ from pypetkitapi.const import (
     DEVICES_FEEDER,
     FEEDER,
     FEEDER_MINI,
+    K2,
+    K3,
     T3,
     T4,
     T5,
@@ -27,11 +29,19 @@ from pypetkitapi.const import (
 class DeviceCommand(StrEnum):
     """Device Command"""
 
+    POWER = "power_device"
+    CONTROL_DEVICE = "control_device"
     UPDATE_SETTING = "update_setting"
 
 
+class FountainCommand(StrEnum):
+    """Device Command"""
+
+    CONTROL_DEVICE = "control_device"
+
+
 class FeederCommand(StrEnum):
-    """Feeder Command"""
+    """Specific Feeder Command"""
 
     CALL_PET = "call_pet"
     CALIBRATION = "food_reset"
@@ -45,25 +55,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,29 +81,43 @@ 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):
     """Fountain Action"""
 
+    MODE_NORMAL = "Normal"
+    MODE_SMART = "Smart"
+    MODE_STANDARD = "Standard"
+    MODE_INTERMITTENT = "Intermittent"
     PAUSE = "Pause"
-    NORMAL_TO_PAUSE = "Normal To Pause"
-    SMART_TO_PAUSE = "Smart To Pause"
-    NORMAL = "Normal"
-    SMART = "Smart"
+    CONTINUE = "Continue"
+    POWER_OFF = "Power Off"
+    POWER_ON = "Power On"
     RESET_FILTER = "Reset Filter"
     DO_NOT_DISTURB = "Do Not Disturb"
     DO_NOT_DISTURB_OFF = "Do Not Disturb Off"
-    FIRST_BLE_CMND = "First BLE Command"
-    SECOND_BLE_CMND = "Second BLE Command"
     LIGHT_LOW = "Light Low"
     LIGHT_MEDIUM = "Light Medium"
     LIGHT_HIGH = "Light High"
@@ -109,20 +125,12 @@ class FountainAction(StrEnum):
     LIGHT_OFF = "Light Off"
 
 
-FOUNTAIN_COMMAND_TO_CODE = {
-    FountainAction.DO_NOT_DISTURB: "221",
-    FountainAction.DO_NOT_DISTURB_OFF: "221",
-    FountainAction.LIGHT_ON: "221",
-    FountainAction.LIGHT_OFF: "221",
-    FountainAction.LIGHT_LOW: "221",
-    FountainAction.LIGHT_MEDIUM: "221",
-    FountainAction.LIGHT_HIGH: "221",
-    FountainAction.PAUSE: "220",
-    FountainAction.RESET_FILTER: "222",
-    FountainAction.NORMAL: "220",
-    FountainAction.NORMAL_TO_PAUSE: "220",
-    FountainAction.SMART: "220",
-    FountainAction.SMART_TO_PAUSE: "220",
+FOUNTAIN_COMMAND = {
+    FountainAction.PAUSE: [220, 1, 3, 0, 1, 0, 2],
+    FountainAction.CONTINUE: [220, 1, 3, 0, 1, 1, 2],
+    FountainAction.RESET_FILTER: [222, 1, 0, 0],
+    FountainAction.POWER_OFF: [220, 1, 3, 0, 0, 1, 1],
+    FountainAction.POWER_ON: [220, 1, 3, 0, 1, 1, 1],
 }
 
 
@@ -137,18 +145,18 @@ class CmdData:
 
 def get_endpoint_manual_feed(device):
     """Get the endpoint for the device"""
-    if device.device_type == FEEDER_MINI:
+    if device.device_nfo.device_type == FEEDER_MINI:
         return PetkitEndpoint.MANUAL_FEED_MINI
-    if device.device_type == FEEDER:
+    if device.device_nfo.device_type == FEEDER:
         return PetkitEndpoint.MANUAL_FEED_FRESH_ELEMENT
     return PetkitEndpoint.MANUAL_FEED_DUAL
 
 
 def get_endpoint_reset_desiccant(device):
     """Get the endpoint for the device"""
-    if device.device_type == FEEDER_MINI:
+    if device.device_nfo.device_type == FEEDER_MINI:
         return PetkitEndpoint.MINI_DESICCANT_RESET
-    if device.device_type == FEEDER:
+    if device.device_nfo.device_type == FEEDER:
         return PetkitEndpoint.FRESH_ELEMENT_DESICCANT_RESET
     return PetkitEndpoint.DESICCANT_RESET
 
@@ -162,6 +170,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: {
@@ -204,7 +221,7 @@ ACTIONS_MAP = {
     FeederCommand.CANCEL_MANUAL_FEED: CmdData(
         endpoint=lambda device: (
             PetkitEndpoint.FRESH_ELEMENT_CANCEL_FEED
-            if device.device_type == FEEDER
+            if device.device_nfo.device_type == FEEDER
             else PetkitEndpoint.CANCEL_FEED
         ),
         params=lambda device: {
@@ -212,7 +229,7 @@ ACTIONS_MAP = {
             "deviceId": device.id,
             **(
                 {"id": device.manual_feed_id}
-                if device.device_type.lower() in [D4H, D4S, D4SH]
+                if device.device_nfo.device_type in [D4H, D4S, D4SH]
                 else {}
             ),
         },
@@ -255,15 +272,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: {
@@ -272,15 +280,4 @@ ACTIONS_MAP = {
         },
         supported_device=ALL_DEVICES,
     ),
-    # FountainCommand.CONTROL_DEVICE: CmdData(
-    #     endpoint=PetkitEndpoint.CONTROL_DEVICE,
-    #     params=lambda device, setting: {
-    #         "bleId": device.id,
-    #         "cmd": cmnd_code,
-    #         "data": ble_data,
-    #         "mac": device.mac,
-    #         "type": water_fountain.ble_relay,
-    #     },
-    #     supported_device=[CTW3],
-    # ),
 }

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"
@@ -14,6 +11,11 @@ DEVICE_DATA = "deviceData"
 DEVICE_STATS = "deviceStats"
 PET_DATA = "petData"
 
+# Bluetooth
+BLE_CONNECT_ATTEMPT = 4
+BLE_START_TRAME = [250, 252, 253]
+BLE_END_TRAME = [251]
+
 # PetKit Models
 FEEDER = "feeder"
 FEEDER_MINI = "feedermini"
@@ -30,11 +32,18 @@ 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):
@@ -116,11 +125,12 @@ class PetkitEndpoint(StrEnum):
     GET_DEVICE_RECORD_RELEASE = "getDeviceRecordRelease"
     UPDATE_SETTING = "updateSettings"
 
-    # Bluetooth relay
+    # Bluetooth
     BLE_AS_RELAY = "ble/ownSupportBleDevices"
     BLE_CONNECT = "ble/connect"
     BLE_POLL = "ble/poll"
     BLE_CANCEL = "ble/cancel"
+    BLE_CONTROL_DEVICE = "ble/controlDevice"
 
     # Fountain & Litter Box
     CONTROL_DEVICE = "controlDevice"

pypetkitapi/containers.py

@@ -1,6 +1,6 @@
 """Dataclasses container for petkit API."""
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 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):
@@ -56,24 +57,31 @@ class Device(BaseModel):
     device_type: str = Field(alias="deviceType")
     group_id: int = Field(alias="groupId")
     type: int
-    type_code: int = Field(alias="typeCode")
+    type_code: int = Field(0, alias="typeCode")
     unique_id: str = Field(alias="uniqueId")
 
+    @field_validator("device_name", "device_type", "unique_id", mode="before")
+    def convert_to_lower(cls, value):  # noqa: N805
+        """Convert device_name, device_type and unique_id to lowercase."""
+        if value is not None and isinstance(value, str):
+            return value.lower()
+        return value
+
 
 class Pet(BaseModel):
     """Dataclass for pet data.
     Subclass of AccountData.
     """
 
-    avatar: str | None = None
+    avatar: str
     created_at: int = Field(alias="createdAt")
     pet_id: int = Field(alias="petId")
-    pet_name: str | None = Field(None, alias="petName")
+    pet_name: str = Field(alias="petName")
     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)
-    device_type: str = "pet"  # Fictive fixed field (for HA compatibility)
     firmware: str | None = None  # Fictive fixed field (for HA compatibility)
+    device_nfo: Device | None = None  # Device is now optional
 
     # Litter stats
     last_litter_usage: int = 0
@@ -85,9 +93,7 @@ class Pet(BaseModel):
         """Initialize the Pet dataclass.
         This method is used to fill the fictive fields after the standard initialization.
         """
-        # Appeler l'initialisation standard de Pydantic
         super().__init__(**data)
-        # Remplir les champs fictifs après l'initialisation
         self.id = self.id or self.pet_id
         self.sn = self.sn or str(self.id)
         self.name = self.name or self.pet_name

pypetkitapi/feeder_container.py

@@ -267,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:
@@ -290,7 +291,7 @@ class FeederRecord(BaseModel):
         if request_date is None:
             request_date = datetime.now().strftime("%Y%m%d")
 
-        if device.device_type.lower() == D4:
+        if device.device_type == D4:
             return {"date": request_date, "type": 0, "deviceId": device.device_id}
         return {"days": request_date, "deviceId": device.device_id}
 
@@ -305,7 +306,6 @@ class Feeder(BaseModel):
     cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")
     created_at: str | None = Field(None, alias="createdAt")
     device_records: FeederRecord | None = None
-    device_type: str | None = Field(None, alias="deviceType")
     firmware: float
     firmware_details: list[FirmwareDetail] | None = Field(None, alias="firmwareDetails")
     hardware: int
@@ -326,6 +326,7 @@ class Feeder(BaseModel):
     sn: str
     state: StateFeeder | None = None
     timezone: float | None = None
+    device_nfo: Device | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

pypetkitapi/litter_container.py

@@ -235,7 +235,6 @@ 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:
@@ -254,7 +253,7 @@ class LitterRecord(BaseModel):
         request_date: str | None = None,
     ) -> dict:
         """Generate query parameters including request_date."""
-        device_type = device.device_type.lower()
+        device_type = device.device_type
         if device_type == T4:
             if request_date is None:
                 request_date = datetime.now().strftime("%Y%m%d")
@@ -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/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/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,11 @@ 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
+    is_connected: bool = False
+    ble_counter: int = 0
+    last_ble_poll: str | None = None
 
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:

{pypetkitapi-1.7.10.dist-info → pypetkitapi-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.7.10
+Version: 1.9.0
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
@@ -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
@@ -99,7 +101,10 @@ async def main():
 
         ### Example 2 : Feed the pet
         ### Device_ID, Command, Payload
+        # simple hopper :
         await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount": 1})
+        # dual hopper :
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED_DUAL, {"amount1": 2})
 
         ### Example 3 : Start the cleaning process
         ### Device_ID, Command, Payload
@@ -110,6 +115,10 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+## More example usage
+
+Check at the usage in the Home Assistant integration : [here](https://github.com/Jezza34000/homeassistant_petkit)
+
 ## Contributing
 
 Contributions are welcome! Please open an issue or submit a pull request.

pypetkitapi-1.9.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pypetkitapi/__init__.py,sha256=FSbNIvn4PuEEWbVnJ2rQEQkyOZgCYiXVAgrWqokbnVg,1562
+pypetkitapi/client.py,sha256=J7d8lgrCyR1fJPEB9zUTu_z7HVDp_ALgD_qihu9KAYo,27630
+pypetkitapi/command.py,sha256=G7AEtUcaK-lcRliNf4oUxPkvDO_GNBkJ-ZUcOo7DGHM,7697
+pypetkitapi/const.py,sha256=pkTJ0l-8mQix9aoJNC2UYfyUdG7ie826xnv7EkOZtPw,4208
+pypetkitapi/containers.py,sha256=oJR22ZruMr-0IRgiucdnj_nutOH59MKvmaFTwLJNiJI,4635
+pypetkitapi/exceptions.py,sha256=fuTLT6Iw2_kA7eOyNJPf59vQkgfByhAnTThY4lC0Rt0,1283
+pypetkitapi/feeder_container.py,sha256=q9lsUvBMxVt-vs8gE3Gg7jVyiIz_eh-3Vq-vMhDIzGA,14472
+pypetkitapi/litter_container.py,sha256=kVbPddHV7wjaeBbRIsigHn_-G42qLZyFUXJg5U5PcQ0,19061
+pypetkitapi/medias.py,sha256=IuWkC7usw0Hbx173X8TGv24jOp4nqv6bIUosZBpXMGg,6945
+pypetkitapi/purifier_container.py,sha256=ssyIxhNben5XJ4KlQTXTrtULg2ji6DqHqjzOq08d1-I,2491
+pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypetkitapi/water_fountain_container.py,sha256=5J0b-fDZYcFLNX2El7fifv8H6JMhBCt-ttxSow1ozRQ,6787
+pypetkitapi-1.9.0.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
+pypetkitapi-1.9.0.dist-info/METADATA,sha256=ga5bwlaFeRelb8zt8nUMGpSt6X8Uh3mvnbbJwjYteEU,5167
+pypetkitapi-1.9.0.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pypetkitapi-1.9.0.dist-info/RECORD,,

{pypetkitapi-1.7.10.dist-info → pypetkitapi-1.9.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pypetkitapi-1.7.10.dist-info/RECORD

@@ -1,15 +0,0 @@
-pypetkitapi/__init__.py,sha256=r1w3zjlBQJOVxP43DyaVDvtsGOGm5nKYTBqhS8KqQkA,908
-pypetkitapi/client.py,sha256=VsISt7-njR0eFlloJenBjMXqeHjnrXXJr-7wamNA3fk,20473
-pypetkitapi/command.py,sha256=q_9B-_z74BicMKNTR46PpELhmqW1cUV8q-95D6riJy4,7959
-pypetkitapi/const.py,sha256=RzGVarP4lfF7eYjpp5XOPgDcen8zJYBucZSn0Lcj3rw,4044
-pypetkitapi/containers.py,sha256=8A_ShIqIt4PNL7c7_OAipVq3OFb5wCPiyGAp4UgenX4,4417
-pypetkitapi/exceptions.py,sha256=fuTLT6Iw2_kA7eOyNJPf59vQkgfByhAnTThY4lC0Rt0,1283
-pypetkitapi/feeder_container.py,sha256=97vcOe6WaX-pi2d2-VPfn3WMYvPffhv4DEpGPMA_cQo,14457
-pypetkitapi/litter_container.py,sha256=lcoWt3SRSrAaH11DXybSNT3n5KAMamMkOW-CRv2jYJI,18332
-pypetkitapi/medias.py,sha256=IuWkC7usw0Hbx173X8TGv24jOp4nqv6bIUosZBpXMGg,6945
-pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypetkitapi/water_fountain_container.py,sha256=3F4GP5pXJqq6kxLMSK__GgFMuZ-rz1VDIIhaVd19Kl8,6781
-pypetkitapi-1.7.10.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
-pypetkitapi-1.7.10.dist-info/METADATA,sha256=xNrfF_madK5tDmGzl-O1F-eHhHwBe5yMaB5ljE7O9no,4853
-pypetkitapi-1.7.10.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pypetkitapi-1.7.10.dist-info/RECORD,,