pypetkitapi 0.5.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

pypetkitapi/client.py

@@ -12,6 +12,8 @@ from aiohttp import ContentTypeError
 
 from pypetkitapi.command import ACTIONS_MAP
 from pypetkitapi.const import (
+    DEVICE_DATA,
+    DEVICE_RECORDS,
     DEVICES_FEEDER,
     DEVICES_LITTER_BOX,
     DEVICES_WATER_FOUNTAIN,
@@ -20,10 +22,10 @@ from pypetkitapi.const import (
     RES_KEY,
     SUCCESS_KEY,
     Header,
+    PetkitDomain,
     PetkitEndpoint,
-    PetkitURL,
 )
-from pypetkitapi.containers import AccountData, Device, RegionInfo, SessionInfo
+from pypetkitapi.containers import AccountData, Device, Pet, RegionInfo, SessionInfo
 from pypetkitapi.exceptions import (
     PetkitAuthenticationError,
     PetkitInvalidHTTPResponseCodeError,
@@ -32,9 +34,9 @@ from pypetkitapi.exceptions import (
     PetkitTimeoutError,
     PypetkitError,
 )
-from pypetkitapi.feeder_container import Feeder
-from pypetkitapi.litter_container import Litter
-from pypetkitapi.water_fountain_container import WaterFountain
+from pypetkitapi.feeder_container import Feeder, FeederRecord
+from pypetkitapi.litter_container import Litter, LitterRecord
+from pypetkitapi.water_fountain_container import WaterFountain, WaterFountainRecord
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -46,8 +48,10 @@ class PetKitClient:
     _session: SessionInfo | None = None
     _servers_list: list[RegionInfo] = []
     account_data: list[AccountData] = []
-    # TODO : Adding pet as entity ?
-    device_list: dict[int, Feeder | Litter | WaterFountain] = {}
+    petkit_entities: dict[int, Feeder | Litter | WaterFountain | Pet] = {}
+    petkit_entities_records: dict[
+        int, FeederRecord | LitterRecord | WaterFountainRecord
+    ] = {}
 
     def __init__(
         self,
@@ -55,85 +59,49 @@ class PetKitClient:
         password: str,
         region: str,
         timezone: str,
+        session: aiohttp.ClientSession | None = None,
     ) -> None:
         """Initialize the PetKit Client."""
         self.username = username
         self.password = password
         self.region = region.lower()
         self.timezone = timezone
-
-    async def _generate_header(self) -> dict[str, str]:
-        """Create header for interaction with devices."""
-        session_id = self._session.id if self._session is not None else ""
-
-        return {
-            "Accept": Header.ACCEPT.value,
-            "Accept-Language": Header.ACCEPT_LANG,
-            "Accept-Encoding": Header.ENCODING,
-            "Content-Type": Header.CONTENT_TYPE,
-            "User-Agent": Header.AGENT,
-            "X-Img-Version": Header.IMG_VERSION,
-            "X-Locale": Header.LOCALE,
-            "F-Session": session_id,
-            "X-Session": session_id,
-            "X-Client": Header.CLIENT,
-            "X-Hour": Header.HOUR,
-            "X-TimezoneId": Header.TIMEZONE_ID,
-            "X-Api-Version": Header.API_VERSION,
-            "X-Timezone": Header.TIMEZONE,
-        }
-
-    async def _get_api_server_list(self) -> None:
-        """Get the list of API servers and set the base URL."""
-        _LOGGER.debug("Getting API server list")
-        prep_req = PrepReq(base_url=PetkitURL.REGION_SRV)
-        response = await prep_req.request(
-            method=HTTPMethod.GET,
-            url="",
-            headers=await self._generate_header(),
+        self._session = None
+        self.aiohttp_session = session or aiohttp.ClientSession()
+        self.req = PrepReq(
+            base_url=PetkitDomain.PASSPORT_PETKIT, session=self.aiohttp_session
         )
-        _LOGGER.debug("API server list: %s", response)
-        self._servers_list = [
-            RegionInfo(**region) for region in response.get("list", [])
-        ]
 
     async def _get_base_url(self) -> None:
-        """Find the region server for the specified region."""
-        await self._get_api_server_list()
-        _LOGGER.debug("Finding region server for region: %s", self.region)
+        """Get the list of API servers, filter by region, and return the matching server."""
+        _LOGGER.debug("Getting API server list")
 
-        # TODO : Improve this
-        if self.region == "china":
-            self._base_url = PetkitURL.CHINA_SRV
+        if self.region.lower() == "china":
+            self._base_url = PetkitDomain.CHINA_SRV
             return
 
-        regional_server = next(
-            (
-                server
-                for server in self._servers_list
-                if server.name.lower() == self.region
-                or server.id.lower() == self.region
-            ),
-            None,
+        response = await self.req.request(
+            method=HTTPMethod.GET,
+            url=PetkitEndpoint.REGION_SERVERS,
         )
+        _LOGGER.debug("API server list: %s", response)
 
-        if regional_server:
-            _LOGGER.debug(
-                "Using server %s for region : %s", regional_server, self.region
-            )
-            self._base_url = regional_server.gateway
-            return
+        # Filter the servers by region
+        for region in response.get("list", []):
+            server = RegionInfo(**region)
+            if server.name.lower() == self.region or server.id.lower() == self.region:
+                self.req.base_url = server.gateway
+                _LOGGER.debug("Found matching server: %s", server)
+                return
         raise PetkitRegionalServerNotFoundError(self.region)
 
     async def request_login_code(self) -> bool:
         """Request a login code to be sent to the user's email."""
         _LOGGER.debug("Requesting login code for username: %s", self.username)
-        prep_req = PrepReq(base_url=self._base_url)
-        response = await prep_req.request(
+        response = await self.req.request(
             method=HTTPMethod.GET,
             url=PetkitEndpoint.GET_LOGIN_CODE,
             params={"username": self.username},
-            headers=await self._generate_header(),
         )
         if response:
             _LOGGER.info("Login code sent to user's email")
@@ -145,7 +113,7 @@ class PetKitClient:
         # Retrieve the list of servers
         await self._get_base_url()
 
-        _LOGGER.debug("Logging in to PetKit server")
+        _LOGGER.info("Logging in to PetKit server")
 
         # Prepare the data to send
         data = LOGIN_DATA.copy()
@@ -162,12 +130,10 @@ class PetKitClient:
             data["password"] = pwd  # noqa: S324
 
         # Send the login request
-        prep_req = PrepReq(base_url=self._base_url)
-        response = await prep_req.request(
+        response = await self.req.request(
             method=HTTPMethod.POST,
             url=PetkitEndpoint.LOGIN,
             data=data,
-            headers=await self._generate_header(),
         )
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
@@ -175,11 +141,9 @@ class PetKitClient:
     async def refresh_session(self) -> None:
         """Refresh the session."""
         _LOGGER.debug("Refreshing session")
-        prep_req = PrepReq(base_url=self._base_url)
-        response = await prep_req.request(
+        response = await self.req.request(
             method=HTTPMethod.POST,
             url=PetkitEndpoint.REFRESH_SESSION,
-            headers=await self._generate_header(),
         )
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
@@ -207,83 +171,150 @@ class PetKitClient:
             await self.refresh_session()
         return
 
+    async def get_session_id(self) -> dict:
+        """Return the session ID."""
+        if self._session is None:
+            raise PypetkitError("Session is not initialized.")
+        return {"F-Session": self._session.id, "X-Session": self._session.id}
+
     async def _get_account_data(self) -> None:
         """Get the account data from the PetKit service."""
         await self.validate_session()
         _LOGGER.debug("Fetching account data")
-        prep_req = PrepReq(base_url=self._base_url)
-        response = await prep_req.request(
+        response = await self.req.request(
             method=HTTPMethod.GET,
             url=PetkitEndpoint.FAMILY_LIST,
-            headers=await self._generate_header(),
+            headers=await self.get_session_id(),
         )
         self.account_data = [AccountData(**account) for account in response]
 
+        # Add pets to device_list
+        for account in self.account_data:
+            if account.pet_list:
+                for pet in account.pet_list:
+                    self.petkit_entities[pet.pet_id] = pet
+
     async def get_devices_data(self) -> None:
         """Get the devices data from the PetKit servers."""
         start_time = datetime.now()
         if not self.account_data:
             await self._get_account_data()
 
+        tasks = []
         device_list: list[Device] = []
+
         for account in self.account_data:
             _LOGGER.debug("Fetching devices data for account: %s", account)
             if account.device_list:
                 device_list.extend(account.device_list)
 
-        _LOGGER.debug("Fetch %s devices for this account", len(device_list))
-
-        tasks = []
-        for device in device_list:
-            _LOGGER.debug("Fetching devices data: %s", device)
-            device_type = device.device_type.lower()
-            if device_type in DEVICES_FEEDER:
-                tasks.append(self._fetch_device_data(device, Feeder))
-            elif device_type in DEVICES_LITTER_BOX:
-                tasks.append(self._fetch_device_data(device, Litter))
-            elif device_type in DEVICES_WATER_FOUNTAIN:
-                tasks.append(self._fetch_device_data(device, WaterFountain))
-            else:
-                _LOGGER.warning("Unknown device type: %s", device_type)
+            _LOGGER.debug("Fetch %s devices for this account", len(device_list))
+
+            for device in device_list:
+                _LOGGER.debug("Fetching devices data: %s", device)
+                device_type = device.device_type.lower()
+                device_id = device.device_id
+                if device_type in DEVICES_FEEDER:
+                    # Add tasks for feeders
+                    tasks.append(self._fetch_device_data(account, device_id, Feeder))
+                    tasks.append(
+                        self._fetch_device_data(account, device_id, FeederRecord)
+                    )
+                elif device_type in DEVICES_LITTER_BOX:
+                    # Add tasks for litter boxes
+                    tasks.append(self._fetch_device_data(account, device_id, Litter))
+                    tasks.append(
+                        self._fetch_device_data(account, device_id, LitterRecord)
+                    )
+                elif device_type in DEVICES_WATER_FOUNTAIN:
+                    # Add tasks for water fountains
+                    tasks.append(
+                        self._fetch_device_data(account, device_id, WaterFountain)
+                    )
+                    tasks.append(
+                        self._fetch_device_data(account, device_id, WaterFountainRecord)
+                    )
+                else:
+                    _LOGGER.warning("Unknown device type: %s", device_type)
         await asyncio.gather(*tasks)
 
         end_time = datetime.now()
         total_time = end_time - start_time
-        _LOGGER.debug("Petkit fetch took : %s", total_time)
+        _LOGGER.info("OK Petkit data fetched in : %s", total_time)
 
     async def _fetch_device_data(
         self,
-        device: Device,
-        data_class: type[Feeder | Litter | WaterFountain],
+        account: AccountData,
+        device_id: int,
+        data_class: type[
+            Feeder
+            | Litter
+            | WaterFountain
+            | FeederRecord
+            | LitterRecord
+            | WaterFountainRecord
+        ],
     ) -> None:
         """Fetch the device data from the PetKit servers."""
         await self.validate_session()
-        endpoint = data_class.get_endpoint(device.device_type)
+        device = None
+
+        if account.device_list:
+            device = next(
+                (
+                    device
+                    for device in account.device_list
+                    if device.device_id == device_id
+                ),
+                None,
+            )
+        if device is None:
+            _LOGGER.error("Device not found: id=%s", device_id)
+            return
         device_type = device.device_type.lower()
-        query_param = data_class.query_param(device.device_id)
 
-        prep_req = PrepReq(base_url=self._base_url)
-        response = await prep_req.request(
-            method=HTTPMethod.GET,
+        endpoint = data_class.get_endpoint(device_type)
+        query_param = data_class.query_param(account, device.device_id)
+
+        response = await self.req.request(
+            method=HTTPMethod.POST,
             url=f"{device_type}/{endpoint}",
             params=query_param,
-            headers=await self._generate_header(),
-        )
-        device_data = data_class(**response)
-        device_data.device_type = device.device_type  # Add the device_type attribute
-        _LOGGER.debug(
-            "Reading device type : %s (id=%s)", device.device_type, device.device_id
+            headers=await self.get_session_id(),
         )
-        self.device_list[device.device_id] = device_data
+
+        # Check if the response is a list or a dict
+        if isinstance(response, list):
+            device_data = [data_class(**item) for item in response]
+        elif isinstance(response, dict):
+            device_data = data_class(**response)
+        else:
+            _LOGGER.error("Unexpected response type: %s", type(response))
+            return
+
+        if isinstance(device_data, list):
+            for item in device_data:
+                item.device_type = device_type
+        else:
+            device_data.device_type = device_type
+
+        _LOGGER.debug("Reading device type : %s (id=%s)", device_type, device_id)
+
+        if data_class.data_type == DEVICE_DATA:
+            self.petkit_entities[device_id] = device_data
+        elif data_class.data_type == DEVICE_RECORDS:
+            self.petkit_entities_records[device_id] = device_data
+        else:
+            _LOGGER.error("Unknown data type: %s", data_class.data_type)
 
     async def send_api_request(
         self,
         device_id: int,
         action: StrEnum,
-        setting: dict | StrEnum | None = None,
+        setting: dict | None = None,
     ) -> None:
         """Control the device using the PetKit API."""
-        device = self.device_list.get(device_id)
+        device = self.petkit_entities.get(device_id)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
 
@@ -295,57 +326,84 @@ class PetKitClient:
             setting,
         )
 
+        # Check if the device type is supported
         if device.device_type:
             device_type = device.device_type.lower()
         else:
             raise PypetkitError(
                 "Device type is not available, and is mandatory for sending commands."
             )
-
+        # Check if the action is supported
         if action not in ACTIONS_MAP:
             raise PypetkitError(f"Action {action} not supported.")
 
         action_info = ACTIONS_MAP[action]
+        _LOGGER.debug(action)
+        _LOGGER.debug(action_info)
         if device_type not in action_info.supported_device:
             raise PypetkitError(
                 f"Device type {device.device_type} not supported for action {action}."
             )
-
+        # Get the endpoint
         if callable(action_info.endpoint):
             endpoint = action_info.endpoint(device)
+            _LOGGER.debug("Endpoint from callable")
         else:
             endpoint = action_info.endpoint
+            _LOGGER.debug("Endpoint field")
         url = f"{device.device_type.lower()}/{endpoint}"
 
-        headers = await self._generate_header()
-
-        # Use the lambda to generate params
+        # Get the parameters
         if setting is not None:
             params = action_info.params(device, setting)
         else:
             params = action_info.params(device)
 
-        prep_req = PrepReq(base_url=self._base_url)
-        res = await prep_req.request(
+        res = await self.req.request(
             method=HTTPMethod.POST,
             url=url,
             data=params,
-            headers=headers,
+            headers=await self.get_session_id(),
         )
         if res in (SUCCESS_KEY, RES_KEY):
-            # TODO : Manage to get the response from manul feeding
+            # TODO : Manage to get the response from manual feeding
             _LOGGER.info("Command executed successfully")
         else:
             _LOGGER.error("Command execution failed")
 
+    async def close(self) -> None:
+        """Close the aiohttp session if it was created by the client."""
+        if self.aiohttp_session:
+            await self.aiohttp_session.close()
+
 
 class PrepReq:
     """Prepare the request to the PetKit API."""
 
-    def __init__(self, base_url: str, base_headers: dict | None = None) -> None:
+    def __init__(self, base_url: str, session: aiohttp.ClientSession) -> None:
         """Initialize the request."""
         self.base_url = base_url
-        self.base_headers = base_headers or {}
+        self.session = session
+        self.base_headers = self._generate_header()
+
+    @staticmethod
+    def _generate_header() -> dict[str, str]:
+        """Create header for interaction with API endpoint."""
+
+        return {
+            "Accept": Header.ACCEPT.value,
+            "Accept-Language": Header.ACCEPT_LANG,
+            "Accept-Encoding": Header.ENCODING,
+            "Content-Type": Header.CONTENT_TYPE,
+            "User-Agent": Header.AGENT,
+            "X-Img-Version": Header.IMG_VERSION,
+            "X-Locale": Header.LOCALE,
+            "X-Client": Header.CLIENT,
+            "X-Hour": Header.HOUR,
+            "X-TimezoneId": Header.TIMEZONE_ID,
+            "X-Api-Version": Header.API_VERSION,
+            "X-Timezone": Header.TIMEZONE,
+        }
 
     async def request(
         self,
@@ -366,34 +424,21 @@ class PrepReq:
             data,
             _headers,
         )
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.request(
-                    method,
-                    _url,
-                    params=params,
-                    data=data,
-                    headers=_headers,
-                ) as resp:
-                    return await self._handle_response(resp, _url)
-            except ContentTypeError:
-                """If we get an error, lets log everything for debugging."""
-                try:
-                    resp_json = await resp.json(content_type=None)
-                    _LOGGER.info("Resp: %s", resp_json)
-                except ContentTypeError as err_2:
-                    _LOGGER.info(err_2)
-                resp_raw = await resp.read()
-                _LOGGER.info("Resp raw: %s", resp_raw)
-                # Still raise the err so that it's clear it failed.
-                raise
-            except TimeoutError:
-                raise PetkitTimeoutError("The request timed out") from None
+        try:
+            async with self.session.request(
+                method,
+                _url,
+                params=params,
+                data=data,
+                headers=_headers,
+            ) as resp:
+                return await self._handle_response(resp, _url)
+        except aiohttp.ClientConnectorError as e:
+            raise PetkitTimeoutError(f"Cannot connect to host: {e}") from e
 
     @staticmethod
     async def _handle_response(response: aiohttp.ClientResponse, url: str) -> dict:
         """Handle the response from the PetKit API."""
-
         try:
             response.raise_for_status()
         except aiohttp.ClientResponseError as e:
@@ -408,6 +453,7 @@ class PrepReq:
                 "Response is not in JSON format"
             ) from None
 
+        # Check for errors in the response
         if ERR_KEY in response_json:
             error_msg = response_json[ERR_KEY].get("msg", "Unknown error")
             if any(
@@ -421,6 +467,7 @@ class PrepReq:
                 raise PetkitAuthenticationError(f"Login failed: {error_msg}")
             raise PypetkitError(f"Request failed: {error_msg}")
 
+        # Check for success in the response
         if RES_KEY in response_json:
             return response_json[RES_KEY]
 

pypetkitapi/command.py

@@ -3,7 +3,7 @@
 from collections.abc import Callable
 from dataclasses import dataclass, field
 import datetime
-from enum import StrEnum
+from enum import IntEnum, StrEnum
 import json
 
 from pypetkitapi.const import (
@@ -53,7 +53,7 @@ class LitterCommand(StrEnum):
 class PetCommand(StrEnum):
     """PetCommand"""
 
-    UPDATE_SETTING = "update_setting"
+    PET_UPDATE_SETTING = "pet_update_setting"
 
 
 class FountainCommand(StrEnum):
@@ -62,27 +62,22 @@ class FountainCommand(StrEnum):
     CONTROL_DEVICE = "control_device"
 
 
-class LitterBoxCommand(StrEnum):
+class LBCommand(IntEnum):
     """LitterBoxCommand"""
 
-    LIGHT_ON = "light_on"
-    ODOR_REMOVAL = "start_odor"
-    PAUSE_CLEAN = "stop_clean"
-    POWER = "power"
-    RESET_DEODOR = "reset_deodorizer"
-    RESUME_CLEAN = "continue_clean"
-    START_CLEAN = "start_clean"
-    START_MAINTENANCE = "start_maintenance"
-    EXIT_MAINTENANCE = "exit_maintenance"
-    PAUSE_MAINTENANCE_EXIT = "pause_maintenance_exit"
-    RESUME_MAINTENANCE_EXIT = "resume_maintenance_exit"
-    DUMP_LITTER = "dump_litter"
-    PAUSE_LITTER_DUMP = "pause_litter_dump"
-    RESUME_LITTER_DUMP = "resume_litter_dump"
-    RESET_MAX_DEODOR = "reset_max_deodorizer"
-
-
-class LitterBoxCommandKey(StrEnum):
+    CLEANING = 0
+    DUMPING = 1
+    ODOR_REMOVAL = 2
+    RESETTING = 3
+    LEVELING = 4
+    CALIBRATING = 5
+    RESET_DEODOR = 6
+    LIGHT = 7
+    RESET_MAX_DEODOR = 8
+    MAINTENANCE = 9
+
+
+class LBAction(StrEnum):
     """LitterBoxCommandKey"""
 
     CONTINUE = "continue_action"
@@ -92,70 +87,6 @@ class LitterBoxCommandKey(StrEnum):
     STOP = "stop_action"
 
 
-class LitterBoxCommandType(StrEnum):
-    """LitterBoxCommandType"""
-
-    CONTINUE = "continue"
-    END = "end"
-    POWER = "power"
-    START = "start"
-    STOP = "stop"
-
-
-LB_CMD_TO_KEY = {
-    LitterBoxCommand.LIGHT_ON: LitterBoxCommandKey.START,
-    LitterBoxCommand.POWER: LitterBoxCommandKey.POWER,
-    LitterBoxCommand.START_CLEAN: LitterBoxCommandKey.START,
-    LitterBoxCommand.PAUSE_CLEAN: LitterBoxCommandKey.STOP,
-    LitterBoxCommand.RESUME_CLEAN: LitterBoxCommandKey.CONTINUE,
-    LitterBoxCommand.ODOR_REMOVAL: LitterBoxCommandKey.START,
-    LitterBoxCommand.RESET_DEODOR: LitterBoxCommandKey.START,
-    LitterBoxCommand.START_MAINTENANCE: LitterBoxCommandKey.START,
-    LitterBoxCommand.EXIT_MAINTENANCE: LitterBoxCommandKey.END,
-    LitterBoxCommand.PAUSE_MAINTENANCE_EXIT: LitterBoxCommandKey.STOP,
-    LitterBoxCommand.RESUME_MAINTENANCE_EXIT: LitterBoxCommandKey.CONTINUE,
-    LitterBoxCommand.DUMP_LITTER: LitterBoxCommandKey.START,
-    LitterBoxCommand.PAUSE_LITTER_DUMP: LitterBoxCommandKey.STOP,
-    LitterBoxCommand.RESUME_LITTER_DUMP: LitterBoxCommandKey.CONTINUE,
-    LitterBoxCommand.RESET_MAX_DEODOR: LitterBoxCommandKey.START,
-}
-
-LB_CMD_TO_TYPE = {
-    LitterBoxCommand.LIGHT_ON: LitterBoxCommandType.START,
-    LitterBoxCommand.POWER: LitterBoxCommandType.POWER,
-    LitterBoxCommand.START_CLEAN: LitterBoxCommandType.START,
-    LitterBoxCommand.PAUSE_CLEAN: LitterBoxCommandType.STOP,
-    LitterBoxCommand.RESUME_CLEAN: LitterBoxCommandType.CONTINUE,
-    LitterBoxCommand.ODOR_REMOVAL: LitterBoxCommandType.START,
-    LitterBoxCommand.RESET_DEODOR: LitterBoxCommandType.START,
-    LitterBoxCommand.START_MAINTENANCE: LitterBoxCommandType.START,
-    LitterBoxCommand.EXIT_MAINTENANCE: LitterBoxCommandType.END,
-    LitterBoxCommand.PAUSE_MAINTENANCE_EXIT: LitterBoxCommandType.STOP,
-    LitterBoxCommand.RESUME_MAINTENANCE_EXIT: LitterBoxCommandType.CONTINUE,
-    LitterBoxCommand.DUMP_LITTER: LitterBoxCommandType.START,
-    LitterBoxCommand.PAUSE_LITTER_DUMP: LitterBoxCommandType.STOP,
-    LitterBoxCommand.RESUME_LITTER_DUMP: LitterBoxCommandType.CONTINUE,
-    LitterBoxCommand.RESET_MAX_DEODOR: LitterBoxCommandType.START,
-}
-
-LB_CMD_TO_VALUE = {
-    LitterBoxCommand.LIGHT_ON: 7,
-    LitterBoxCommand.START_CLEAN: 0,
-    LitterBoxCommand.PAUSE_CLEAN: 0,
-    LitterBoxCommand.RESUME_CLEAN: 0,
-    LitterBoxCommand.ODOR_REMOVAL: 2,
-    LitterBoxCommand.RESET_DEODOR: 6,
-    LitterBoxCommand.START_MAINTENANCE: 9,
-    LitterBoxCommand.EXIT_MAINTENANCE: 9,
-    LitterBoxCommand.PAUSE_MAINTENANCE_EXIT: 9,
-    LitterBoxCommand.RESUME_MAINTENANCE_EXIT: 9,
-    LitterBoxCommand.DUMP_LITTER: 1,
-    LitterBoxCommand.PAUSE_LITTER_DUMP: 1,
-    LitterBoxCommand.RESUME_LITTER_DUMP: 1,
-    LitterBoxCommand.RESET_MAX_DEODOR: 8,
-}
-
-
 class FountainAction(StrEnum):
     """Fountain Action"""
 
@@ -304,25 +235,16 @@ ACTIONS_MAP = {
         },
         supported_device=[D3],
     ),
-    LitterCommand.POWER: CmdData(
-        endpoint=PetkitEndpoint.CONTROL_DEVICE,
-        params=lambda device, setting: {
-            "id": device.id,
-            "kv": json.dumps(setting),
-            "type": "power",
-        },
-        supported_device=[T3, T4, T5, T6],
-    ),
     LitterCommand.CONTROL_DEVICE: CmdData(
         endpoint=PetkitEndpoint.CONTROL_DEVICE,
         params=lambda device, command: {
             "id": device.id,
-            "kv": json.dumps({LB_CMD_TO_KEY[command]: LB_CMD_TO_VALUE[command]}),
-            "type": LB_CMD_TO_TYPE[command],
+            "kv": json.dumps(command),
+            "type": list(command.keys())[0].split("_")[0],
         },
         supported_device=[T3, T4, T5, T6],
     ),
-    PetCommand.UPDATE_SETTING: CmdData(
+    PetCommand.PET_UPDATE_SETTING: CmdData(
         endpoint=PetkitEndpoint.CONTROL_DEVICE,
         params=lambda pet, setting: {
             "petId": pet,

pypetkitapi/const.py

@@ -9,6 +9,9 @@ RES_KEY = "result"
 ERR_KEY = "error"
 SUCCESS_KEY = "success"
 
+DEVICE_RECORDS = "deviceRecords"
+DEVICE_DATA = "deviceData"
+
 # PetKit Models
 FEEDER = "feeder"
 FEEDER_MINI = "feedermini"
@@ -31,10 +34,10 @@ DEVICES_WATER_FOUNTAIN = [W5, CTW3]
 ALL_DEVICES = [*DEVICES_LITTER_BOX, *DEVICES_FEEDER, *DEVICES_WATER_FOUNTAIN]
 
 
-class PetkitURL(StrEnum):
+class PetkitDomain(StrEnum):
     """Petkit URL constants"""
 
-    REGION_SRV = "https://passport.petkt.com/v1/regionservers"
+    PASSPORT_PETKIT = "https://passport.petkt.com/"
     CHINA_SRV = "https://api.petkit.cn/6/"
 
 
@@ -58,7 +61,7 @@ class Header(StrEnum):
     AGENT = "okhttp/3.12.11"
     CLIENT = f"{Client.PLATFORM_TYPE}({Client.OS_VERSION};{Client.MODEL_NAME})"
     TIMEZONE = "1.0"
-    TIMEZONE_ID = "Europe/Paris"  # TODO: Make this dynamic, check if this really matters (record hours?)
+    TIMEZONE_ID = "Europe/Paris"  # TODO: Make this dynamic
     LOCALE = "en-US"
     IMG_VERSION = "1.0"
     HOUR = "24"
@@ -71,7 +74,7 @@ CLIENT_NFO = {
     "platform": Client.PLATFORM_TYPE.value,
     "source": Client.SOURCE.value,
     "timezone": Header.TIMEZONE.value,  # TODO: Make this dynamic
-    "timezoneId": Header.TIMEZONE_ID.value,  # TODO: Make this dynamic
+    "timezoneId": Header.TIMEZONE_ID.value,
     "version": Header.API_VERSION.value,
 }
 
@@ -84,11 +87,14 @@ LOGIN_DATA = {
 class PetkitEndpoint(StrEnum):
     """Petkit Endpoint constants"""
 
+    REGION_SERVERS = "v1/regionservers"
     LOGIN = "user/login"
     GET_LOGIN_CODE = "user/sendcodeforquicklogin"
     REFRESH_SESSION = "user/refreshsession"
     FAMILY_LIST = "group/family/list"
     REFRESH_HOME_V2 = "refreshHomeV2"
+
+    # Common to many device
     DEVICE_DETAIL = "device_detail"
     DEVICE_DATA = "deviceData"
     GET_DEVICE_RECORD = "getDeviceRecord"
@@ -103,6 +109,7 @@ class PetkitEndpoint(StrEnum):
 
     # Fountain & Litter Box
     CONTROL_DEVICE = "controlDevice"
+    GET_WORK_RECORD = "getWorkRecord"
 
     # Litter Box
     DEODORANT_RESET = "deodorantReset"

pypetkitapi/containers.py

@@ -66,9 +66,10 @@ class Pet(BaseModel):
     """
 
     avatar: str | None = None
-    created_at: int | None = Field(None, alias="createdAt")
-    pet_id: int | None = Field(None, alias="petId")
+    created_at: int = Field(alias="createdAt")
+    pet_id: int = Field(alias="petId")
     pet_name: str | None = Field(None, alias="petName")
+    device_type: str = "pet"
 
 
 class User(BaseModel):

pypetkitapi/feeder_container.py

@@ -1,12 +1,12 @@
 """Dataclasses for feeder data."""
 
-from collections.abc import Callable
+from datetime import datetime
 from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field
 
-from pypetkitapi.const import PetkitEndpoint
-from pypetkitapi.containers import CloudProduct, FirmwareDetail, Wifi
+from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
+from pypetkitapi.containers import AccountData, CloudProduct, FirmwareDetail, Wifi
 
 
 class FeedItem(BaseModel):
@@ -170,8 +170,7 @@ class ManualFeed(BaseModel):
 class Feeder(BaseModel):
     """Dataclass for feeder data."""
 
-    url_endpoint: ClassVar[PetkitEndpoint] = PetkitEndpoint.DEVICE_DETAIL
-    query_param: ClassVar[Callable] = lambda device_id: {"id": device_id}
+    data_type: ClassVar[str] = DEVICE_DATA
 
     auto_upgrade: int | None = Field(None, alias="autoUpgrade")
     bt_mac: str | None = Field(None, alias="btMac")
@@ -202,7 +201,12 @@ class Feeder(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        return cls.url_endpoint.value
+        return PetkitEndpoint.DEVICE_DETAIL
+
+    @classmethod
+    def query_param(cls, account: AccountData, device_id: int) -> dict:
+        """Generate query parameters including request_date."""
+        return {"id": device_id}
 
 
 class EventState(BaseModel):
@@ -217,8 +221,8 @@ class EventState(BaseModel):
     surplus_standard: int | None = Field(None, alias="surplusStandard")
 
 
-class FeederRecord(BaseModel):
-    """Dataclass for feeder record data."""
+class RecordsItems(BaseModel):
+    """Dataclass for records items data."""
 
     aes_key: str | None = Field(None, alias="aesKey")
     duration: int | None = None
@@ -259,3 +263,40 @@ class FeederRecord(BaseModel):
     src: int | None = None
     state: EventState | None = None
     status: int | None = None
+
+
+class RecordsType(BaseModel):
+    """Dataclass for records type data."""
+
+    add_amount1: int | None = Field(None, alias="addAmount1")
+    add_amount2: int | None = Field(None, alias="addAmount2")
+    day: int | None = None
+    device_id: int | None = Field(None, alias="deviceId")
+    eat_count: int | None = Field(None, alias="eatCount")
+    items: list[RecordsItems] | None = None
+
+
+class FeederRecord(BaseModel):
+    """Dataclass for feeder record data."""
+
+    data_type: ClassVar[str] = DEVICE_RECORDS
+
+    eat: list[RecordsType] | None = None
+    feed: list[RecordsType] | None = None
+    move: list[RecordsType] | None = None
+    pet: list[RecordsType] | None = None
+    device_type: str | None = Field(None, alias="deviceType")
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.GET_DEVICE_RECORD
+
+    @classmethod
+    def query_param(
+        cls, account: AccountData, device_id: int, request_date: str | None = None
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        if request_date is None:
+            request_date = datetime.now().strftime("%Y%m%d")
+        return {"days": int(request_date), "deviceId": device_id}

pypetkitapi/litter_container.py

@@ -1,12 +1,12 @@
 """Dataclasses for Litter."""
 
-from collections.abc import Callable
+from datetime import datetime
 from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field
 
-from pypetkitapi.const import PetkitEndpoint
-from pypetkitapi.containers import CloudProduct, FirmwareDetail, Wifi
+from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
+from pypetkitapi.containers import AccountData, CloudProduct, FirmwareDetail, Wifi
 
 
 class SettingsLitter(BaseModel):
@@ -147,8 +147,7 @@ class Litter(BaseModel):
     Supported devices = T4, T6
     """
 
-    url_endpoint: ClassVar[PetkitEndpoint] = PetkitEndpoint.DEVICE_DETAIL
-    query_param: ClassVar[Callable] = lambda device_id: {"id": device_id}
+    data_type: ClassVar[str] = DEVICE_DATA
 
     auto_upgrade: int | None = Field(None, alias="autoUpgrade")
     bt_mac: str | None = Field(None, alias="btMac")
@@ -187,4 +186,64 @@ class Litter(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        return cls.url_endpoint.value
+        return PetkitEndpoint.DEVICE_DETAIL
+
+    @classmethod
+    def query_param(cls, account: AccountData, device_id: int) -> dict:
+        """Generate query parameters including request_date."""
+        return {"id": device_id}
+
+
+class Content(BaseModel):
+    """Dataclass for content data."""
+
+    box: int | None = None
+    box_full: bool | None = Field(None, alias="boxFull")
+    litter_percent: int | None = Field(None, alias="litterPercent")
+    result: int | None = None
+    start_reason: int | None = Field(None, alias="startReason")
+    start_time: int | None = Field(None, alias="startTime")
+
+
+class SubContent(BaseModel):
+    """Dataclass for sub-content data."""
+
+    content: Content | None = None
+    device_id: int | None = Field(None, alias="deviceId")
+    enum_event_type: str | None = Field(None, alias="enumEventType")
+    event_type: int | None = Field(None, alias="eventType")
+    sub_content: list[Any] | None = Field(None, alias="subContent")
+    timestamp: int | None = None
+    user_id: str | None = Field(None, alias="userId")
+
+
+class LitterRecord(BaseModel):
+    """Dataclass for feeder record data."""
+
+    data_type: ClassVar[str] = DEVICE_RECORDS
+
+    avatar: str | None = None
+    content: dict[str, Any] | None = None
+    device_id: int | None = Field(None, alias="deviceId")
+    enum_event_type: str | None = Field(None, alias="enumEventType")
+    event_type: int | None = Field(None, alias="eventType")
+    pet_id: str | None = Field(None, alias="petId")
+    pet_name: str | None = Field(None, alias="petName")
+    sub_content: list[SubContent] | None = Field(None, alias="subContent")
+    timestamp: 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."""
+        return PetkitEndpoint.GET_DEVICE_RECORD
+
+    @classmethod
+    def query_param(
+        cls, account: AccountData, device_id: int, request_date: str | None = None
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        if request_date is None:
+            request_date = datetime.now().strftime("%Y%m%d")
+        return {"date": int(request_date), "deviceId": device_id}

pypetkitapi/water_fountain_container.py

@@ -1,11 +1,12 @@
 """Dataclasses for Water Fountain."""
 
-from collections.abc import Callable
+from datetime import datetime
 from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field
 
-from pypetkitapi.const import PetkitEndpoint
+from pypetkitapi.const import DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
+from pypetkitapi.containers import AccountData
 
 
 class Electricity(BaseModel):
@@ -89,8 +90,7 @@ class WaterFountain(BaseModel):
     Supported devices = CTW3
     """
 
-    url_endpoint: ClassVar[PetkitEndpoint] = PetkitEndpoint.DEVICE_DATA
-    query_param: ClassVar[Callable] = lambda device_id: {"id": device_id}
+    data_type: ClassVar[str] = DEVICE_DATA
 
     breakdown_warning: int | None = Field(None, alias="breakdownWarning")
     created_at: str | None = Field(None, alias="createdAt")
@@ -132,4 +132,41 @@ class WaterFountain(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        return cls.url_endpoint.value
+        return PetkitEndpoint.DEVICE_DATA
+
+    @classmethod
+    def query_param(cls, account: AccountData, device_id: int) -> dict:
+        """Generate query parameters including request_date."""
+        return {"id": device_id}
+
+
+class WaterFountainRecord(BaseModel):
+    """Dataclass for feeder record data."""
+
+    data_type: ClassVar[str] = DEVICE_RECORDS
+
+    day_time: int | None = Field(None, alias="dayTime")
+    stay_time: int | None = Field(None, alias="stayTime")
+    work_time: int | None = Field(None, alias="workTime")
+    device_type: str | None = Field(None, alias="deviceType")
+
+    @classmethod
+    def get_endpoint(cls, device_type: str) -> str:
+        """Get the endpoint URL for the given device type."""
+        return PetkitEndpoint.GET_WORK_RECORD
+
+    @classmethod
+    def query_param(
+        cls, account: AccountData, device_id: int, request_date: str | None = None
+    ) -> dict:
+        """Generate query parameters including request_date."""
+        if not account.user_list or not account.user_list[0]:
+            raise ValueError("The account does not have a valid user_list.")
+
+        if request_date is None:
+            request_date = datetime.now().strftime("%Y%m%d")
+        return {
+            "day": int(request_date),
+            "deviceId": device_id,
+            "userId": account.user_list[0].user_id,
+        }

{pypetkitapi-0.5.3.dist-info → pypetkitapi-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypetkitapi
-Version: 0.5.3
+Version: 1.0.0
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
@@ -20,19 +20,23 @@ Description-Content-Type: text/markdown
 ---
 
 [![PyPI](https://img.shields.io/pypi/v/pypetkitapi.svg)][pypi_]
-[![Python Version](https://img.shields.io/pypi/pyversions/pypetkitapi)][python version]
+[![Python Version](https://img.shields.io/pypi/pyversions/pypetkitapi)][python version] [![Actions status](https://github.com/Jezza34000/py-petkit-api/workflows/CI/badge.svg)](https://github.com/Jezza34000/py-petkit-api/actions)
+
+---
+
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
 
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
 [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
 [![mypy](https://img.shields.io/badge/mypy-checked-blue)](https://mypy.readthedocs.io/en/stable/)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Actions status](https://github.com/Jezza34000/py-petkit-api/workflows/CI/badge.svg)](https://github.com/Jezza34000/py-petkit-api/actions)
 
 ---
 
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
-
 [pypi_]: https://pypi.org/project/pypetkitapi/
 [python version]: https://pypi.org/project/pypetkitapi
 [pre-commit]: https://github.com/pre-commit/pre-commit
@@ -59,38 +63,42 @@ 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
 
 logging.basicConfig(level=logging.DEBUG)
 
-
 async def main():
-    client = PetKitClient(
-        username="username",  # Your PetKit account username or id
-        password="password",  # Your PetKit account password
-        region="France",  # Your region or country code (e.g. FR, US, etc.)
-        timezone="Europe/Paris",  # Your timezone
-    )
-
-    # To get the account and devices data attached to the account
-    await client.get_devices_data()
-
-    # Read the account data
-    print(client.account_data)
-
-    # Read the devices data
-    print(client.device_list)
-
-    # Send command to the devices
-    ### Example 1 : Turn on the indicator light
-    ### Device_ID, Command, Payload
-    await client.send_api_request(012346789, DeviceCommand.UPDATE_SETTING, {"lightMode": 1})
-
-    ### Example 2 : Feed the pet
-    ### Device_ID, Command, Payload
-    await client.send_api_request(0123467, FeederCommand.MANUAL_FEED, {"amount": 1})
+    async with aiohttp.ClientSession() as session:
+        client = PetKitClient(
+            username="username",  # Your PetKit account username or id
+            password="password",  # Your PetKit account password
+            region="FR",  # Your region or country code (e.g. FR, US, etc.)
+            timezone="Europe/Paris",  # Your timezone
+            session=session,
+        )
+
+        await client.get_devices_data()
+
+        # Read the account data
+        print(client.account_data)
+
+        # Read the devices data
+        print(client.petkit_entities)
+
+        # Send command to the devices
+        ### Example 1 : Turn on the indicator light
+        ### Device_ID, Command, Payload
+        await client.send_api_request(123456789, DeviceCommand.UPDATE_SETTING, {"lightMode": 1})
+
+        ### Example 2 : Feed the pet
+        ### Device_ID, Command, Payload
+        await client.send_api_request(123456789, FeederCommand.MANUAL_FEED, {"amount": 1})
+
+        ### Example 3 : Start the cleaning process
+        ### Device_ID, Command, Payload
+        await client.send_api_request(123456789, LitterCommand.CONTROL_DEVICE, {LBAction.START: LBCommand.CLEANING})
 
 
 if __name__ == "__main__":

pypetkitapi-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pypetkitapi/__init__.py,sha256=eVpyGMD3tkYtiHUkdKEeNSZhQlZ4woI2Y5oVoV7CwXM,61
+pypetkitapi/client.py,sha256=RCt3vxNJ14NKzwUpvL_M6xSYC4DfxEyDu7B8sJ7HFz0,16591
+pypetkitapi/command.py,sha256=gw3_J_oZHuuGLk66P8uRSqSrySjYa8ArpKaPHi2ybCw,7155
+pypetkitapi/const.py,sha256=EE84cCOEE6AMv3QuDJa8-FreCffhfq8nxPxqBpvB5XY,3270
+pypetkitapi/containers.py,sha256=m7vzWcJG0U1EPftuBF6OB8eTVRhCoA2DFqekxI6LozI,3428
+pypetkitapi/exceptions.py,sha256=NWmpsI2ewC4HaIeu_uFwCeuPIHIJxZBzjoCP7aNwvhs,1139
+pypetkitapi/feeder_container.py,sha256=XpZqeQ8E4_ud3juxDBKGTMfmCfvc9QYcJInacmbWK-o,12785
+pypetkitapi/litter_container.py,sha256=TK2-_yg3EmT0RQzMLurud2PHwa2P-o2KGyV9m_SQ7qw,11651
+pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypetkitapi/water_fountain_container.py,sha256=xmqYuxyppRLhqi7cF4JNRprhgmz3KKrbi4iv942wNaU,6566
+pypetkitapi-1.0.0.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
+pypetkitapi-1.0.0.dist-info/METADATA,sha256=t1zmfg9-IZqpzBWybjhVTExCgkVJ50Vu8W-Twx8njiE,4590
+pypetkitapi-1.0.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pypetkitapi-1.0.0.dist-info/RECORD,,

pypetkitapi-0.5.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-pypetkitapi/__init__.py,sha256=eVpyGMD3tkYtiHUkdKEeNSZhQlZ4woI2Y5oVoV7CwXM,61
-pypetkitapi/client.py,sha256=wQqX5qH0NMWx0uSLo6fmn4ELhBHcegiEjEwsOrLJaOA,14945
-pypetkitapi/command.py,sha256=MZbnmWpmekVzlWCg_ubcrFnOoqUCZh1Bamcf_QUos38,10605
-pypetkitapi/const.py,sha256=B4uf3RGEkKmpVOo69DRP9g8hF_bodCA7vohnPjnrPFs,3183
-pypetkitapi/containers.py,sha256=4O79O9HZn4kksQysXGXcqVwvkdxbvhs1pr-0WRNCANc,3425
-pypetkitapi/exceptions.py,sha256=NWmpsI2ewC4HaIeu_uFwCeuPIHIJxZBzjoCP7aNwvhs,1139
-pypetkitapi/feeder_container.py,sha256=6a1Y_mTSGuD8qK1YqmiCfxPbZl84bcoIIP_d5g-UctQ,11381
-pypetkitapi/litter_container.py,sha256=baeIihndFfU5F3kxtyO8Dm1qx1mPuMAUIYRH60CV3GM,9447
-pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypetkitapi/water_fountain_container.py,sha256=LcCTDjk7eSbnF7e38xev3D5mCv5wwJ6go8WGGBv-CaU,5278
-pypetkitapi-0.5.3.dist-info/LICENSE,sha256=4FWnKolNLc1e3w6cVlT61YxfPh0DQNeQLN1CepKKSBg,1067
-pypetkitapi-0.5.3.dist-info/METADATA,sha256=S43iNnEv3nDgaYIlF38R24rLVKlRCB-1wkqGRFK25B0,3611
-pypetkitapi-0.5.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pypetkitapi-0.5.3.dist-info/RECORD,,