pypetkitapi 1.9.1__py3-none-any.whl → 1.9.3__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.9.1"
+__version__ = "1.9.3"
 
 __all__ = [
     "CTW3",

pypetkitapi/client.py

@@ -17,6 +17,7 @@ from pypetkitapi.const import (
     BLE_CONNECT_ATTEMPT,
     BLE_END_TRAME,
     BLE_START_TRAME,
+    CLIENT_NFO,
     DEVICE_DATA,
     DEVICE_RECORDS,
     DEVICE_STATS,
@@ -25,6 +26,8 @@ from pypetkitapi.const import (
     DEVICES_PURIFIER,
     DEVICES_WATER_FOUNTAIN,
     ERR_KEY,
+    LITTER_NO_CAMERA,
+    LITTER_WITH_CAMERA,
     LOGIN_DATA,
     PET,
     RES_KEY,
@@ -57,8 +60,22 @@ 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.utils import get_timezone_offset
 from pypetkitapi.water_fountain_container import WaterFountain, WaterFountainRecord
 
+data_handlers = {}
+
+
+def data_handler(data_type):
+    """Register a data handler for a specific data type."""
+
+    def wrapper(func):
+        data_handlers[data_type] = func
+        return func
+
+    return wrapper
+
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -86,7 +103,9 @@ class PetKitClient:
         self.petkit_entities = {}
         self.aiohttp_session = session or aiohttp.ClientSession()
         self.req = PrepReq(
-            base_url=PetkitDomain.PASSPORT_PETKIT, session=self.aiohttp_session
+            base_url=PetkitDomain.PASSPORT_PETKIT,
+            session=self.aiohttp_session,
+            timezone=self.timezone,
         )
 
     async def _get_base_url(self) -> None:
@@ -134,7 +153,12 @@ class PetKitClient:
         _LOGGER.info("Logging in to PetKit server")
 
         # Prepare the data to send
+        client_nfo = CLIENT_NFO.copy()
+        client_nfo["timezoneId"] = self.timezone
+        client_nfo["timezone"] = get_timezone_offset(self.timezone)
+
         data = LOGIN_DATA.copy()
+        data["client"] = str(client_nfo)
         data["encrypt"] = "1"
         data["region"] = self.region
         data["username"] = self.username
@@ -223,7 +247,7 @@ class PetKitClient:
                         groupId=0,
                         type=0,
                         typeCode=0,
-                        uniqueId=pet.sn,
+                        uniqueId=str(pet.sn),
                     )
 
     async def get_devices_data(self) -> None:
@@ -234,16 +258,31 @@ class PetKitClient:
         if not self.account_data:
             await self._get_account_data()
 
-        main_tasks = []
-        record_tasks = []
-        device_list: list[Device] = []
+        device_list = self._collect_devices()
+        main_tasks, record_tasks = self._prepare_tasks(device_list)
+
+        await asyncio.gather(*main_tasks)
+        await asyncio.gather(*record_tasks)
+        await self._execute_stats_tasks()
 
+        end_time = datetime.now()
+        _LOGGER.debug("Petkit data fetched successfully in: %s", end_time - start_time)
+
+    def _collect_devices(self) -> list[Device]:
+        """Collect all devices from account data."""
+        device_list = []
         for account in self.account_data:
             _LOGGER.debug("List devices data for account: %s", account)
             if account.device_list:
                 _LOGGER.debug("Devices in account: %s", account.device_list)
                 device_list.extend(account.device_list)
                 _LOGGER.debug("Found %s devices", len(account.device_list))
+        return device_list
+
+    def _prepare_tasks(self, device_list: list[Device]) -> tuple[list, list]:
+        """Prepare main and record tasks based on device types."""
+        main_tasks = []
+        record_tasks = []
 
         for device in device_list:
             device_type = device.device_type
@@ -253,15 +292,9 @@ class PetKitClient:
                 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),
-                )
+                main_tasks.append(self._fetch_device_data(device, Litter))
                 record_tasks.append(self._fetch_device_data(device, LitterRecord))
-
-                if device_type in [T3, T4]:
-                    record_tasks.append(self._fetch_device_data(device, LitterStats))
-                if device_type in [T5, T6]:
-                    record_tasks.append(self._fetch_device_data(device, PetOutGraph))
+                self._add_litter_box_tasks(record_tasks, device_type, device)
 
             elif device_type in DEVICES_WATER_FOUNTAIN:
                 main_tasks.append(self._fetch_device_data(device, WaterFountain))
@@ -272,26 +305,26 @@ class PetKitClient:
             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)
+        return main_tasks, record_tasks
 
-        # Then execute record tasks
-        await asyncio.gather(*record_tasks)
+    def _add_litter_box_tasks(
+        self, record_tasks: list, device_type: str, device: Device
+    ):
+        """Add specific tasks for litter box devices."""
+        if device_type in [T3, T4]:
+            record_tasks.append(self._fetch_device_data(device, LitterStats))
+        if device_type in [T5, T6]:
+            record_tasks.append(self._fetch_device_data(device, PetOutGraph))
 
-        # Add populate_pet_stats tasks
+    async def _execute_stats_tasks(self) -> None:
+        """Execute tasks to populate pet stats."""
         stats_tasks = [
-            self.populate_pet_stats(self.petkit_entities[device.device_id])
-            for device in device_list
-            if device.device_type in DEVICES_LITTER_BOX
+            self.populate_pet_stats(entity)
+            for device_id, entity in self.petkit_entities.items()
+            if isinstance(entity, Litter)
         ]
-
-        # Execute stats tasks
         await asyncio.gather(*stats_tasks)
 
-        end_time = datetime.now()
-        total_time = end_time - start_time
-        _LOGGER.debug("Petkit data fetched successfully in: %s", total_time)
-
     async def _fetch_device_data(
         self,
         device: Device,
@@ -345,23 +378,48 @@ class PetKitClient:
             _LOGGER.error("Unexpected response type: %s", type(response))
             return
 
-        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
+        # Dispatch to the appropriate handler
+        handler = data_handlers.get(data_class.data_type)
+        if handler:
+            await handler(self, device, device_data, device_type)
+        else:
+            _LOGGER.error("Unknown data type: %s", data_class.data_type)
+
+    @data_handler(DEVICE_DATA)
+    async def _handle_device_data(self, device, device_data, device_type):
+        """Handle 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)
+
+    @data_handler(DEVICE_RECORDS)
+    async def _handle_device_records(self, device, device_data, device_type):
+        """Handle device records."""
+        entity = self.petkit_entities.get(device.device_id)
+        if entity and isinstance(entity, (Feeder, Litter, WaterFountain)):
+            entity.device_records = device_data
             _LOGGER.debug("Device records fetched OK for %s", device_type)
-        elif data_class.data_type == DEVICE_STATS:
-            if device_type in [T3, T4]:
-                self.petkit_entities[device.device_id].device_stats = device_data
-            if device_type in [T5, T6]:
-                self.petkit_entities[device.device_id].device_pet_graph_out = (
-                    device_data
-                )
+        else:
+            _LOGGER.warning(
+                "Cannot assign device_records to entity of type %s",
+                type(entity),
+            )
+
+    @data_handler(DEVICE_STATS)
+    async def _handle_device_stats(self, device, device_data, device_type):
+        """Handle device stats."""
+        entity = self.petkit_entities.get(device.device_id)
+        if isinstance(entity, Litter):
+            if device_type in LITTER_NO_CAMERA:
+                entity.device_stats = device_data
+            if device_type in LITTER_WITH_CAMERA:
+                entity.device_pet_graph_out = device_data
             _LOGGER.debug("Device stats fetched OK for %s", device_type)
         else:
-            _LOGGER.error("Unknown data type: %s", data_class.data_type)
+            _LOGGER.warning(
+                "Cannot assign device_stats or device_pet_graph_out to entity of type %s",
+                type(entity),
+            )
 
     async def get_pets_list(self) -> list[Pet]:
         """Extract and return the list of pets."""
@@ -386,6 +444,12 @@ class PetKitClient:
     async def populate_pet_stats(self, stats_data: Litter) -> None:
         """Collect data from litter data to populate pet stats."""
 
+        if not stats_data.device_nfo:
+            _LOGGER.warning(
+                "No device info for %s can't populate pet infos", stats_data
+            )
+            return
+
         pets_list = await self.get_pets_list()
         for pet in pets_list:
             if (
@@ -433,25 +497,27 @@ class PetKitClient:
     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:
+        if not isinstance(water_fountain, WaterFountain):
             _LOGGER.error("Water fountain with ID %s not found.", fountain_id)
-            raise ValueError(f"Water fountain with ID {fountain_id} not found.")
+            raise TypeError(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 account.device_list:
+                fountain = next(
+                    (
+                        device
+                        for device in account.device_list
+                        if device.device_id == fountain_id
+                    ),
+                    None,
+                )
+                if fountain:
+                    break
 
         if not fountain:
             raise ValueError(
@@ -568,13 +634,13 @@ class PetKitClient:
             _LOGGER.error("BLE connection not established.")
             return False
 
-        command = FOUNTAIN_COMMAND.get[command, None]
-        if command is None:
+        command_data = FOUNTAIN_COMMAND.get(command)
+        if command_data is None:
             _LOGGER.error("Command not found.")
             return False
 
         cmd_code, cmd_data = await self.get_ble_cmd_data(
-            command, water_fountain.ble_counter
+            list(command_data), water_fountain.ble_counter
         )
 
         response = await self.req.request(
@@ -607,6 +673,8 @@ class PetKitClient:
         device = self.petkit_entities.get(device_id, None)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
+        if device.device_nfo is None:
+            raise PypetkitError(f"Device with ID {device_id} has no device_nfo.")
 
         _LOGGER.debug(
             "Control API device=%s id=%s action=%s param=%s",
@@ -669,29 +737,30 @@ class PetKitClient:
 class PrepReq:
     """Prepare the request to the PetKit API."""
 
-    def __init__(self, base_url: str, session: aiohttp.ClientSession) -> None:
+    def __init__(
+        self, base_url: str, session: aiohttp.ClientSession, timezone: str
+    ) -> None:
         """Initialize the request."""
         self.base_url = base_url
         self.session = session
+        self.timezone = timezone
         self.base_headers = self._generate_header()
 
-    @staticmethod
-    def _generate_header() -> dict[str, str]:
+    def _generate_header(self) -> 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,
+            "Accept-Language": Header.ACCEPT_LANG.value,
+            "Accept-Encoding": Header.ENCODING.value,
+            "Content-Type": Header.CONTENT_TYPE.value,
+            "User-Agent": Header.AGENT.value,
+            "X-Img-Version": Header.IMG_VERSION.value,
+            "X-Locale": Header.LOCALE.value,
+            "X-Client": Header.CLIENT.value,
+            "X-Hour": Header.HOUR.value,
+            "X-TimezoneId": self.timezone,
+            "X-Api-Version": Header.API_VERSION.value,
+            "X-Timezone": get_timezone_offset(self.timezone),
         }
 
     async def request(

pypetkitapi/const.py

@@ -35,6 +35,8 @@ K3 = "k3"
 PET = "pet"
 
 DEVICES_LITTER_BOX = [T3, T4, T5, T6]
+LITTER_WITH_CAMERA = [T5, T6]
+LITTER_NO_CAMERA = [T3, T4]
 DEVICES_FEEDER = [FEEDER, FEEDER_MINI, D3, D4, D4S, D4H, D4SH]
 DEVICES_WATER_FOUNTAIN = [W5, CTW3]
 DEVICES_PURIFIER = [K2]
@@ -68,12 +70,10 @@ class Header(StrEnum):
     ACCEPT = "*/*"
     ACCEPT_LANG = "en-US;q=1, it-US;q=0.9"
     ENCODING = "gzip, deflate"
-    API_VERSION = "11.3.1"
+    API_VERSION = "11.4.0"
     CONTENT_TYPE = "application/x-www-form-urlencoded"
     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
     LOCALE = "en-US"
     IMG_VERSION = "1.0"
     HOUR = "24"
@@ -85,14 +85,11 @@ CLIENT_NFO = {
     "osVersion": Client.OS_VERSION.value,
     "platform": Client.PLATFORM_TYPE.value,
     "source": Client.SOURCE.value,
-    "timezone": Header.TIMEZONE.value,  # TODO: Make this dynamic
-    "timezoneId": Header.TIMEZONE_ID.value,
     "version": Header.API_VERSION.value,
 }
 
 LOGIN_DATA = {
-    "client": str(CLIENT_NFO),
-    "oldVersion": Header.API_VERSION,
+    "oldVersion": Header.API_VERSION.value,
 }
 
 

pypetkitapi/feeder_container.py

@@ -5,7 +5,15 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel, Field
 
-from pypetkitapi.const import D3, D4, D4S, DEVICE_DATA, DEVICE_RECORDS, PetkitEndpoint
+from pypetkitapi.const import (
+    D3,
+    D4,
+    D4S,
+    DEVICE_DATA,
+    DEVICE_RECORDS,
+    FEEDER_MINI,
+    PetkitEndpoint,
+)
 from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
 
 
@@ -41,7 +49,7 @@ class CameraMultiNew(BaseModel):
 
     enable: int | None = None
     rpt: str | None = None
-    time: list[tuple[int, int]] | None = None
+    time: list[list[int]] | None = None
 
 
 class SettingsFeeder(BaseModel):
@@ -77,9 +85,7 @@ class SettingsFeeder(BaseModel):
     highlight: int | None = None
     light_config: int | None = Field(None, alias="lightConfig")
     light_mode: int | None = Field(None, alias="lightMode")
-    light_multi_range: list[tuple[int, int]] | None = Field(
-        None, alias="lightMultiRange"
-    )
+    light_multi_range: list[list[int]] | None = Field(None, alias="lightMultiRange")
     live_encrypt: int | None = Field(None, alias="liveEncrypt")
     low_battery_notify: int | None = Field(None, alias="lowBatteryNotify")
     manual_lock: int | None = Field(None, alias="manualLock")
@@ -104,7 +110,7 @@ class SettingsFeeder(BaseModel):
     time_display: int | None = Field(None, alias="timeDisplay")
     tone_config: int | None = Field(None, alias="toneConfig")
     tone_mode: int | None = Field(None, alias="toneMode")
-    tone_multi_range: list[tuple[int, int]] | None = Field(None, alias="toneMultiRange")
+    tone_multi_range: list[list[int]] | None = Field(None, alias="toneMultiRange")
     upload: int | None = None
     volume: int | None = None
 
@@ -276,8 +282,10 @@ class FeederRecord(BaseModel):
             return PetkitEndpoint.DAILY_FEED_AND_EAT
         if device_type == D4:
             return PetkitEndpoint.FEED_STATISTIC
-        if device_type == D4S:
+        if device_type in D4S:
             return PetkitEndpoint.DAILY_FEED
+        if device_type in FEEDER_MINI:
+            return PetkitEndpoint.DAILY_FEED.lower()  # Workaround for Feeder Mini
         return PetkitEndpoint.GET_DEVICE_RECORD
 
     @classmethod
@@ -305,8 +313,9 @@ class Feeder(BaseModel):
     bt_mac: str | None = Field(None, alias="btMac")
     cloud_product: CloudProduct | None = Field(None, alias="cloudProduct")
     created_at: str | None = Field(None, alias="createdAt")
+    desc: str | None = None  # D3
     device_records: FeederRecord | None = None
-    firmware: float
+    firmware: str
     firmware_details: list[FirmwareDetail] | None = Field(None, alias="firmwareDetails")
     hardware: int
     id: int

pypetkitapi/litter_container.py

@@ -9,10 +9,9 @@ from pypetkitapi.const import (
     DEVICE_DATA,
     DEVICE_RECORDS,
     DEVICE_STATS,
+    LITTER_NO_CAMERA,
+    LITTER_WITH_CAMERA,
     T3,
-    T4,
-    T5,
-    T6,
     PetkitEndpoint,
 )
 from pypetkitapi.containers import CloudProduct, Device, FirmwareDetail, Wifi
@@ -240,9 +239,9 @@ class LitterRecord(BaseModel):
     @classmethod
     def get_endpoint(cls, device_type: str) -> str:
         """Get the endpoint URL for the given device type."""
-        if device_type in [T3, T4]:
+        if device_type in LITTER_NO_CAMERA:
             return PetkitEndpoint.GET_DEVICE_RECORD
-        if device_type in [T5, T6]:
+        if device_type in LITTER_WITH_CAMERA:
             return PetkitEndpoint.GET_DEVICE_RECORD_RELEASE
         raise ValueError(f"Invalid device type: {device_type}")
 
@@ -255,11 +254,11 @@ class LitterRecord(BaseModel):
     ) -> dict:
         """Generate query parameters including request_date."""
         device_type = device.device_type
-        if device_type in [T3, T4]:
+        if device_type in LITTER_NO_CAMERA:
             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]:
+        if device_type in LITTER_WITH_CAMERA:
             return {
                 "timestamp": int(datetime.now().timestamp()),
                 "deviceId": device.device_id,
@@ -407,7 +406,7 @@ class K3Device(BaseModel):
 
 class Litter(BaseModel):
     """Dataclass for Litter Data.
-    Supported devices = T3, T4, T6
+    Supported devices = T3, T4, T5, T6
     """
 
     data_type: ClassVar[str] = DEVICE_DATA

pypetkitapi/medias.py

@@ -4,13 +4,14 @@ from dataclasses import dataclass
 import logging
 from pathlib import Path
 import re
+from typing import Any
 
 from aiofiles import open as aio_open
 import aiohttp
 from Crypto.Cipher import AES
 from Crypto.Util.Padding import unpad
 
-from pypetkitapi.feeder_container import Feeder, RecordsItems
+from pypetkitapi.feeder_container import Feeder, RecordsType
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -68,7 +69,7 @@ class MediaHandler:
         return self.media_files
 
     async def _process_records(
-        self, records: RecordsItems, record_type: str
+        self, records: RecordsType, record_type: str
     ) -> list[MediasFiles]:
         """Process individual records and return media info."""
         media_files = []
@@ -104,8 +105,8 @@ class MediaHandler:
                 )
 
         for record in records:
-            if record.items:
-                await process_item(record.items)
+            if hasattr(record, "items"):
+                await process_item(record.items)  # type: ignore[attr-defined]
 
         return media_files
 
@@ -170,9 +171,8 @@ class MediaDownloadDecode:
             )
         return file_path
 
-    async def _decrypt_image_from_file(
-        self, file_path: Path, aes_key: str
-    ) -> bytes | None:
+    @staticmethod
+    async def _decrypt_image_from_file(file_path: Path, aes_key: str) -> bytes | None:
         """Decrypt an image from a file using AES encryption.
         :param file_path: Path to the encrypted image file.
         :param aes_key: AES key used for decryption.
@@ -183,13 +183,13 @@ class MediaDownloadDecode:
                 aes_key = aes_key[:-1]
             key_bytes: bytes = aes_key.encode("utf-8")
             iv: bytes = b"\x61" * 16
-            cipher: AES = AES.new(key_bytes, AES.MODE_CBC, iv)
+            cipher: Any = AES.new(key_bytes, AES.MODE_CBC, iv)
 
             async with aio_open(file_path, "rb") as encrypted_file:
                 encrypted_data: bytes = await encrypted_file.read()
 
             decrypted_data: bytes = unpad(
-                cipher.decrypt(encrypted_data), AES.block_size
+                cipher.decrypt(encrypted_data), AES.block_size  # type: ignore[attr-defined]
             )
         except Exception as e:  # noqa: BLE001
             logging.error("Error decrypting image from file %s: %s", file_path, e)

pypetkitapi/utils.py

@@ -0,0 +1,22 @@
+"""Utils functions for the PyPetKit API."""
+
+from datetime import datetime
+import logging
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def get_timezone_offset(timezone_user: str) -> str:
+    """Get the timezone offset from its name. Return 0.0 if an error occurs."""
+    try:
+        timezone = ZoneInfo(timezone_user)
+        now = datetime.now(timezone)
+        offset = now.utcoffset()
+        if offset is None:
+            return "0.0"
+        offset_in_hours = offset.total_seconds() / 3600
+        return str(offset_in_hours)
+    except (ZoneInfoNotFoundError, AttributeError) as e:
+        _LOGGER.warning("Cannot get timezone offset for %s: %s", timezone_user, e)
+        return "0.0"

{pypetkitapi-1.9.1.dist-info → pypetkitapi-1.9.3.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Jezza34000
+Copyright (c) 2024 - 2025 Jezza34000
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{pypetkitapi-1.9.1.dist-info → pypetkitapi-1.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pypetkitapi
-Version: 1.9.1
+Version: 1.9.3
 Summary: Python client for PetKit API
 Home-page: https://github.com/Jezza34000/pypetkit
 License: MIT
@@ -32,6 +32,12 @@ Description-Content-Type: text/markdown
 [![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)
+[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=bugs)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=code_smells)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=Jezza34000_py-petkit-api)
+
+[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=Jezza34000_py-petkit-api&metric=ncloc)](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]

pypetkitapi-1.9.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+pypetkitapi/__init__.py,sha256=dQiuXe1aOwEGmW27csDtKRVc4vhXrqvsW-0ElcbrTRY,1562
+pypetkitapi/client.py,sha256=oi1GhGIcvWMP5J9ueN2Y1xDX-Wm91b7LfjTVSe_plk4,30357
+pypetkitapi/command.py,sha256=G7AEtUcaK-lcRliNf4oUxPkvDO_GNBkJ-ZUcOo7DGHM,7697
+pypetkitapi/const.py,sha256=xDsF6sdxqQPy0B0Qhpe0Nn5xrkDjfo_omL4XL_oXFDE,4050
+pypetkitapi/containers.py,sha256=oJR22ZruMr-0IRgiucdnj_nutOH59MKvmaFTwLJNiJI,4635
+pypetkitapi/exceptions.py,sha256=fuTLT6Iw2_kA7eOyNJPf59vQkgfByhAnTThY4lC0Rt0,1283
+pypetkitapi/feeder_container.py,sha256=ZGJhgqP-gjTFB2q91XoyZQ_G1S5cAY37JoqqHbzoanU,14640
+pypetkitapi/litter_container.py,sha256=-z2BtdtRg8RyLJzJYY3AIACs9GGZ0C64hVhW4do6yQo,19172
+pypetkitapi/medias.py,sha256=ZFdiPj24crYYFwKBUqlxKhfKGrW2uXoXzDl2vWukZ-A,7036
+pypetkitapi/purifier_container.py,sha256=ssyIxhNben5XJ4KlQTXTrtULg2ji6DqHqjzOq08d1-I,2491
+pypetkitapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypetkitapi/utils.py,sha256=z7325kcJQUburnF28HSXrJMvY_gY9007K73Zwxp-4DQ,743
+pypetkitapi/water_fountain_container.py,sha256=5J0b-fDZYcFLNX2El7fifv8H6JMhBCt-ttxSow1ozRQ,6787
+pypetkitapi-1.9.3.dist-info/LICENSE,sha256=u5jNkZEn6YMrtN4Kr5rU3TcBJ5-eAt0qMx4JDsbsnzM,1074
+pypetkitapi-1.9.3.dist-info/METADATA,sha256=p0SF9NMmun43lj81I0Sbc24o7JwFhuQgHoOK4tTquC8,6115
+pypetkitapi-1.9.3.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pypetkitapi-1.9.3.dist-info/RECORD,,

pypetkitapi-1.9.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-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,,