pypetkitapi 1.8.1__py3-none-any.whl → 1.9.1__py3-none-any.whl

pypetkitapi/__init__.py

@@ -40,7 +40,7 @@ from .medias import MediaHandler, MediasFiles
 from .purifier_container import Purifier
 from .water_fountain_container import WaterFountain
 
-__version__ = "1.8.1"
+__version__ = "1.9.1"
 
 __all__ = [
     "CTW3",

pypetkitapi/client.py

@@ -1,17 +1,22 @@
 """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,
@@ -23,13 +28,22 @@ from pypetkitapi.const import (
     LOGIN_DATA,
     PET,
     RES_KEY,
+    T3,
     T4,
+    T5,
     T6,
     Header,
     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,
@@ -201,7 +215,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)
+                    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."""
@@ -223,7 +246,7 @@ 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))
@@ -235,9 +258,9 @@ class PetKitClient:
                 )
                 record_tasks.append(self._fetch_device_data(device, LitterRecord))
 
-                if device_type == T4:
+                if device_type in [T3, T4]:
                     record_tasks.append(self._fetch_device_data(device, LitterStats))
-                if device_type == T6:
+                if device_type in [T5, T6]:
                     record_tasks.append(self._fetch_device_data(device, PetOutGraph))
 
             elif device_type in DEVICES_WATER_FOUNTAIN:
@@ -259,7 +282,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
@@ -285,7 +308,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)
 
@@ -330,9 +353,9 @@ class PetKitClient:
             self.petkit_entities[device.device_id].device_records = device_data
             _LOGGER.debug("Device records fetched OK for %s", device_type)
         elif data_class.data_type == DEVICE_STATS:
-            if device_type == T4:
+            if device_type in [T3, T4]:
                 self.petkit_entities[device.device_id].device_stats = device_data
-            if device_type == T6:
+            if device_type in [T5, T6]:
                 self.petkit_entities[device.device_id].device_pet_graph_out = (
                     device_data
                 )
@@ -365,17 +388,20 @@ class PetKitClient:
 
         pets_list = await self.get_pets_list()
         for pet in pets_list:
-            if stats_data.device_nfo.device_type == T4 and stats_data.device_records:
-                await self._process_t4(pet, stats_data.device_records)
+            if (
+                stats_data.device_nfo.device_type in [T3, T4]
+                and stats_data.device_records
+            ):
+                await self._process_t3_t4(pet, stats_data)
             elif (
-                stats_data.device_nfo.device_type == T6
+                stats_data.device_nfo.device_type in [T5, T6]
                 and stats_data.device_pet_graph_out
             ):
-                await self._process_t6(pet, stats_data.device_pet_graph_out)
+                await self._process_t5_t6(pet, stats_data)
 
-    async def _process_t4(self, pet, device_records):
-        """Process T4 device records."""
-        for stat in device_records:
+    async def _process_t3_t4(self, pet, device_records):
+        """Process T3/T4 devices records."""
+        for stat in device_records.device_records:
             if stat.pet_id == pet.pet_id and (
                 pet.last_litter_usage is None
                 or self.get_safe_value(stat.timestamp) > pet.last_litter_usage
@@ -388,11 +414,11 @@ class PetKitClient:
                     stat.content.time_in if stat.content else None,
                     stat.content.time_out if stat.content else None,
                 )
-                pet.last_device_used = "Pura Max"
+                pet.last_device_used = device_records.device_nfo.device_name
 
-    async def _process_t6(self, pet, pet_graphs):
-        """Process T6 pet graphs."""
-        for graph in pet_graphs:
+    async def _process_t5_t6(self, pet, pet_graphs):
+        """Process T5/T6 pet graphs."""
+        for graph in pet_graphs.device_pet_graph_out:
             if graph.pet_id == pet.pet_id and (
                 pet.last_litter_usage is None
                 or self.get_safe_value(graph.time) > pet.last_litter_usage
@@ -402,7 +428,172 @@ class PetKitClient:
                     graph.content.pet_weight if graph.content else None
                 )
                 pet.last_duration_usage = self.get_safe_value(graph.toilet_time)
-                pet.last_device_used = "Purobot Ultra"
+                pet.last_device_used = pet_graphs.device_nfo.device_name
+
+    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,
@@ -413,7 +604,7 @@ 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.")
 
@@ -427,7 +618,7 @@ class PetKitClient:
 
         # Check if the device type is supported
         if device.device_nfo.device_type:
-            device_type = device.device_nfo.device_type.lower()
+            device_type = device.device_nfo.device_type
         else:
             raise PypetkitError(
                 "Device type is not available, and is mandatory for sending commands."
@@ -452,7 +643,7 @@ class PetKitClient:
         else:
             endpoint = action_info.endpoint
             _LOGGER.debug("Endpoint field")
-        url = f"{device.device_nfo.device_type.lower()}/{endpoint}"
+        url = f"{device.device_nfo.device_type}/{endpoint}"
 
         # Get the parameters
         if setting is not None:
@@ -562,7 +753,7 @@ class PrepReq:
                     )
                 case _:
                     raise PypetkitError(
-                        f"Request failed code : {error_code} details : {error_msg}"
+                        f"Request failed code : {error_code}, details : {error_msg} url : {url}"
                     )
 
         # Check for success in the response

pypetkitapi/command.py

@@ -34,6 +34,12 @@ class DeviceCommand(StrEnum):
     UPDATE_SETTING = "update_setting"
 
 
+class FountainCommand(StrEnum):
+    """Device Command"""
+
+    CONTROL_DEVICE = "control_device"
+
+
 class FeederCommand(StrEnum):
     """Specific Feeder Command"""
 
@@ -101,16 +107,17 @@ class DeviceAction(StrEnum):
 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"
@@ -118,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],
 }
 
 
@@ -146,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
 
@@ -222,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: {
@@ -230,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 {}
             ),
         },
@@ -281,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

@@ -11,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"
@@ -120,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):
@@ -51,14 +51,21 @@ class Device(BaseModel):
     Subclass of AccountData.
     """
 
-    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
+    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(0, alias="typeCode")
-    unique_id: str | None = Field(None, alias="uniqueId")
+    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):
@@ -66,15 +73,15 @@ class Pet(BaseModel):
     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)
     firmware: str | None = None  # Fictive fixed field (for HA compatibility)
-    device_nfo: Device = Field(default_factory=Device)
+    device_nfo: Device | None = None  # Device is now optional
 
     # Litter stats
     last_litter_usage: int = 0

pypetkitapi/feeder_container.py

@@ -291,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}
 

pypetkitapi/litter_container.py

@@ -9,6 +9,7 @@ from pypetkitapi.const import (
     DEVICE_DATA,
     DEVICE_RECORDS,
     DEVICE_STATS,
+    T3,
     T4,
     T5,
     T6,
@@ -239,7 +240,7 @@ class LitterRecord(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        if device_type == T4:
+        if device_type in [T3, T4]:
             return PetkitEndpoint.GET_DEVICE_RECORD
         if device_type in [T5, T6]:
             return PetkitEndpoint.GET_DEVICE_RECORD_RELEASE
@@ -253,11 +254,11 @@ class LitterRecord(BaseModel):
         request_date: str | None = None,
     ) -> dict:
         """Generate query parameters including request_date."""
-        device_type = device.device_type.lower()
-        if device_type == T4:
-            if request_date is None:
-                request_date = datetime.now().strftime("%Y%m%d")
-            return {"date": int(request_date), "deviceId": device.device_id}
+        device_type = device.device_type
+        if device_type in [T3, T4]:
+            request_date = request_date or datetime.now().strftime("%Y%m%d")
+            key = "day" if device_type == T3 else "date"
+            return {key: int(request_date), "deviceId": device.device_id}
         if device_type in [T5, T6]:
             return {
                 "timestamp": int(datetime.now().timestamp()),

pypetkitapi/water_fountain_container.py

@@ -164,6 +164,9 @@ class WaterFountain(BaseModel):
     water_pump_run_time: int | None = Field(None, alias="waterPumpRunTime")
     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.8.1.dist-info → pypetkitapi-1.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.8.1
+Version: 1.9.1
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
@@ -101,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
@@ -112,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.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+pypetkitapi/__init__.py,sha256=MLvrbBarlxdGzxkVY1NW80hTgkSy9fYe5_cuy1mnHbQ,1562
+pypetkitapi/client.py,sha256=o8dBNxdupWwf7AIt6GB4Jc4SLExc0Zv1E-eX2Qjt5FY,27807
+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=qKP3XFUkbzLREZPXEMDvpR1sqo6BI560O6eJYdkrX7w,19110
+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.1.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
+pypetkitapi-1.9.1.dist-info/METADATA,sha256=qp69EJwHbxvvY3Ve870iLQ2mmWBUwz6ePPTfn5YpALw,5167
+pypetkitapi-1.9.1.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pypetkitapi-1.9.1.dist-info/RECORD,,

{pypetkitapi-1.8.1.dist-info → pypetkitapi-1.9.1.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.8.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-pypetkitapi/__init__.py,sha256=qV8NZZeCMyY22gFOav0uic4QiORt9TsenDZkfC0aBqY,1562
-pypetkitapi/client.py,sha256=_iR45tRH59FEQ_Ra1RAMAyTDvpzSLLCNtiKu1yJSW24,20886
-pypetkitapi/command.py,sha256=ONP2BBdnb1nGgAK0xz50GiLO3KPzuQJD1BjqAhblkAs,8165
-pypetkitapi/const.py,sha256=q0HCUoryVyNzuH8erMrTqAR8yW4vEiPE79TTbhKNIEM,4076
-pypetkitapi/containers.py,sha256=9fJVXG-F0lTGcfYyz0WF9xTph5FCQJbqS8LHE5MpZhE,4411
-pypetkitapi/exceptions.py,sha256=fuTLT6Iw2_kA7eOyNJPf59vQkgfByhAnTThY4lC0Rt0,1283
-pypetkitapi/feeder_container.py,sha256=l8SbimdfWhmKcHYINw9_3-jXo9Rxy1K_dV3eSnn7wyk,14480
-pypetkitapi/litter_container.py,sha256=UkF3eAV4ehPcCM0eBRZR1ZNc7foHJTnniLW7HZK--oU,19069
-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=_5K2aTpcqHG-VBu7J2vXSZuAjA_SK6DkgV14u5RkFZA,6694
-pypetkitapi-1.8.1.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
-pypetkitapi-1.8.1.dist-info/METADATA,sha256=b1aaD3dPzfW1ftitW2ApBwETN2IAJ8aWRzJnWrfy4PU,4882
-pypetkitapi-1.8.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pypetkitapi-1.8.1.dist-info/RECORD,,