pypetkitapi 1.9.3__py3-none-any.whl → 1.10.1__py3-none-any.whl

pypetkitapi/client.py

@@ -1,22 +1,19 @@
 """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
+import m3u8
 
-from pypetkitapi.command import ACTIONS_MAP, FOUNTAIN_COMMAND, FountainAction
+from pypetkitapi.bluetooth import BluetoothManager
+from pypetkitapi.command import ACTIONS_MAP
 from pypetkitapi.const import (
-    BLE_CONNECT_ATTEMPT,
-    BLE_END_TRAME,
-    BLE_START_TRAME,
     CLIENT_NFO,
     DEVICE_DATA,
     DEVICE_RECORDS,
@@ -26,6 +23,7 @@ from pypetkitapi.const import (
     DEVICES_PURIFIER,
     DEVICES_WATER_FOUNTAIN,
     ERR_KEY,
+    FEEDER_WITH_CAMERA,
     LITTER_NO_CAMERA,
     LITTER_WITH_CAMERA,
     LOGIN_DATA,
@@ -39,20 +37,14 @@ from pypetkitapi.const import (
     PetkitDomain,
     PetkitEndpoint,
 )
-from pypetkitapi.containers import (
-    AccountData,
-    BleRelay,
-    Device,
-    Pet,
-    RegionInfo,
-    SessionInfo,
-)
+from pypetkitapi.containers import AccountData, Device, Pet, RegionInfo, SessionInfo
 from pypetkitapi.exceptions import (
     PetkitAuthenticationError,
     PetkitAuthenticationUnregisteredEmailError,
     PetkitInvalidHTTPResponseCodeError,
     PetkitInvalidResponseFormat,
     PetkitRegionalServerNotFoundError,
+    PetkitSessionError,
     PetkitSessionExpiredError,
     PetkitTimeoutError,
     PypetkitError,
@@ -82,10 +74,6 @@ _LOGGER = logging.getLogger(__name__)
 class PetKitClient:
     """Petkit Client"""
 
-    _session: SessionInfo | None = None
-    account_data: list[AccountData] = []
-    petkit_entities: dict[int, Feeder | Litter | WaterFountain | Purifier | Pet] = {}
-
     def __init__(
         self,
         username: str,
@@ -99,14 +87,21 @@ class PetKitClient:
         self.password = password
         self.region = region.lower()
         self.timezone = timezone
-        self._session = None
-        self.petkit_entities = {}
+        self._session: SessionInfo | None = None
+        self.account_data: list[AccountData] = []
+        self.petkit_entities: dict[
+            int, Feeder | Litter | WaterFountain | Purifier | Pet
+        ] = {}
         self.aiohttp_session = session or aiohttp.ClientSession()
         self.req = PrepReq(
             base_url=PetkitDomain.PASSPORT_PETKIT,
             session=self.aiohttp_session,
             timezone=self.timezone,
         )
+        self.bluetooth_manager = BluetoothManager(self)
+        from pypetkitapi import MediaManager
+
+        self.media_manager = MediaManager()
 
     async def _get_base_url(self) -> None:
         """Get the list of API servers, filter by region, and return the matching server."""
@@ -148,6 +143,7 @@ class PetKitClient:
     async def login(self, valid_code: str | None = None) -> None:
         """Login to the PetKit service and retrieve the appropriate server."""
         # Retrieve the list of servers
+        self._session = None
         await self._get_base_url()
 
         _LOGGER.info("Logging in to PetKit server")
@@ -180,6 +176,8 @@ class PetKitClient:
         )
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
+        expiration_date = datetime.now() + timedelta(seconds=self._session.expires_in)
+        _LOGGER.debug("Login successful (token expiration %s)", expiration_date)
 
     async def refresh_session(self) -> None:
         """Refresh the session."""
@@ -193,6 +191,7 @@ class PetKitClient:
         session_data = response["session"]
         self._session = SessionInfo(**session_data)
         self._session.refreshed_at = datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")
+        _LOGGER.debug("Session refreshed at %s", self._session.refreshed_at)
 
     async def validate_session(self) -> None:
         """Check if the session is still valid and refresh or re-login if necessary."""
@@ -201,31 +200,27 @@ class PetKitClient:
             await self.login()
             return
 
-        created_at = datetime.strptime(
-            self._session.created_at,
-            "%Y-%m-%dT%H:%M:%S.%f%z",
+        created = datetime.strptime(self._session.created_at, "%Y-%m-%dT%H:%M:%S.%f%z")
+        is_expired = datetime.now(tz=created.tzinfo) - created >= timedelta(
+            seconds=self._session.expires_in
         )
-        current_time = datetime.now(tz=created_at.tzinfo)
-        token_age = current_time - created_at
-        max_age = timedelta(seconds=self._session.expires_in)
-        half_max_age = max_age / 2
 
-        if token_age > max_age:
+        if is_expired:
             _LOGGER.debug("Token expired, re-logging in")
             await self.login()
-        elif half_max_age < token_age <= max_age:
-            _LOGGER.debug("Token still OK, but refreshing session")
-            await self.refresh_session()
+        # elif (max_age / 2) < token_age < max_age:
+        #     _LOGGER.debug("Token still OK, but refreshing session")
+        #     await self.refresh_session()
 
     async def get_session_id(self) -> dict:
         """Return the session ID."""
+        await self.validate_session()
         if self._session is None:
-            raise PypetkitError("Session is not initialized.")
+            raise PetkitSessionError("No session ID available")
         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")
         response = await self.req.request(
             method=HTTPMethod.GET,
@@ -252,17 +247,16 @@ class PetKitClient:
 
     async def get_devices_data(self) -> None:
         """Get the devices data from the PetKit servers."""
-        await self.validate_session()
-
         start_time = datetime.now()
         if not self.account_data:
             await self._get_account_data()
 
         device_list = self._collect_devices()
-        main_tasks, record_tasks = self._prepare_tasks(device_list)
+        main_tasks, record_tasks, media_tasks = self._prepare_tasks(device_list)
 
         await asyncio.gather(*main_tasks)
         await asyncio.gather(*record_tasks)
+        await asyncio.gather(*media_tasks)
         await self._execute_stats_tasks()
 
         end_time = datetime.now()
@@ -279,10 +273,11 @@ class PetKitClient:
                 _LOGGER.debug("Found %s devices", len(account.device_list))
         return device_list
 
-    def _prepare_tasks(self, device_list: list[Device]) -> tuple[list, list]:
+    def _prepare_tasks(self, device_list: list[Device]) -> tuple[list, list, list]:
         """Prepare main and record tasks based on device types."""
-        main_tasks = []
-        record_tasks = []
+        main_tasks: list = []
+        record_tasks: list = []
+        media_tasks: list = []
 
         for device in device_list:
             device_type = device.device_type
@@ -290,11 +285,14 @@ class PetKitClient:
             if device_type in DEVICES_FEEDER:
                 main_tasks.append(self._fetch_device_data(device, Feeder))
                 record_tasks.append(self._fetch_device_data(device, FeederRecord))
+                self._add_feeder_task_by_type(media_tasks, device_type, device)
 
             elif device_type in DEVICES_LITTER_BOX:
                 main_tasks.append(self._fetch_device_data(device, Litter))
                 record_tasks.append(self._fetch_device_data(device, LitterRecord))
-                self._add_litter_box_tasks(record_tasks, device_type, device)
+                self._add_lb_task_by_type(
+                    record_tasks, media_tasks, device_type, device
+                )
 
             elif device_type in DEVICES_WATER_FOUNTAIN:
                 main_tasks.append(self._fetch_device_data(device, WaterFountain))
@@ -305,16 +303,24 @@ class PetKitClient:
             elif device_type in DEVICES_PURIFIER:
                 main_tasks.append(self._fetch_device_data(device, Purifier))
 
-        return main_tasks, record_tasks
+        return main_tasks, record_tasks, media_tasks
 
-    def _add_litter_box_tasks(
-        self, record_tasks: list, device_type: str, device: Device
+    def _add_lb_task_by_type(
+        self, record_tasks: list, media_tasks: list, device_type: str, device: Device
     ):
         """Add specific tasks for litter box devices."""
-        if device_type in [T3, T4]:
+        if device_type in LITTER_NO_CAMERA:
             record_tasks.append(self._fetch_device_data(device, LitterStats))
-        if device_type in [T5, T6]:
+        if device_type in LITTER_WITH_CAMERA:
             record_tasks.append(self._fetch_device_data(device, PetOutGraph))
+            media_tasks.append(self._fetch_media(device))
+
+    def _add_feeder_task_by_type(
+        self, media_tasks: list, device_type: str, device: Device
+    ):
+        """Add specific tasks for feeder box devices."""
+        if device_type in FEEDER_WITH_CAMERA:
+            media_tasks.append(self._fetch_media(device))
 
     async def _execute_stats_tasks(self) -> None:
         """Execute tasks to populate pet stats."""
@@ -325,6 +331,15 @@ class PetKitClient:
         ]
         await asyncio.gather(*stats_tasks)
 
+    async def _fetch_media(self, device: Device) -> None:
+        """Fetch media data from the PetKit servers."""
+        _LOGGER.debug("Fetching media data for device: %s", device.device_id)
+
+        device_entity = self.petkit_entities[device.device_id]
+        device_entity.medias = await self.media_manager.get_all_media_files(
+            [device_entity]
+        )
+
     async def _fetch_device_data(
         self,
         device: Device,
@@ -494,172 +509,50 @@ class PetKitClient:
                 pet.last_duration_usage = self.get_safe_value(graph.toilet_time)
                 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 isinstance(water_fountain, WaterFountain):
-            _LOGGER.error("Water fountain with ID %s not found.", fountain_id)
-            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:
-            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(
-                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
-
+    async def get_cloud_video(self, video_url: str) -> dict[str, str | int] | None:
+        """Get the video m3u8 link from the cloud."""
         response = await self.req.request(
             method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CONNECT,
-            data={
-                "bleId": fountain_id,
-                "type": 24,
-                "mac": water_fountain.mac,
-            },
+            url=video_url,
             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 not isinstance(response, list) or not response:
+            _LOGGER.debug(
+                "No video data found from cloud, looks like you don't have a care+ subscription ?"
             )
-            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,
-            },
+            return None
+        return response[0]
+
+    async def extract_segments_m3u8(self, m3u8_url: str) -> tuple[str, str, list[str]]:
+        """Extract segments from the m3u8 file.
+        :param: m3u8_url: URL of the m3u8 file
+        :return: aes_key, key_iv, segment_lst
+        """
+        # Extract segments from m3u8 file
+        response = await self.req.request(
+            method=HTTPMethod.GET,
+            url=m3u8_url,
             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
+        m3u8_obj = m3u8.loads(response[RES_KEY])
 
-        command_data = FOUNTAIN_COMMAND.get(command)
-        if command_data is None:
-            _LOGGER.error("Command not found.")
-            return False
+        if not m3u8_obj.segments or not m3u8_obj.keys:
+            raise PetkitInvalidResponseFormat("No segments or key found in m3u8 file.")
 
-        cmd_code, cmd_data = await self.get_ble_cmd_data(
-            list(command_data), water_fountain.ble_counter
-        )
+        # Extract segments from m3u8 file
+        segment_lst = [segment.uri for segment in m3u8_obj.segments]
+        # Extract key_uri and key_iv from m3u8 file
+        key_uri = m3u8_obj.keys[0].uri
+        key_iv = str(m3u8_obj.keys[0].iv)
 
+        # Extract aes_key from video segments
         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,
-            },
+            method=HTTPMethod.GET,
+            url=key_uri,
+            full_url=True,
             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
+        return response[RES_KEY], key_iv, segment_lst
 
     async def send_api_request(
         self,
@@ -668,8 +561,6 @@ class PetKitClient:
         setting: dict | None = None,
     ) -> bool:
         """Control the device using the PetKit API."""
-        await self.validate_session()
-
         device = self.petkit_entities.get(device_id, None)
         if not device:
             raise PypetkitError(f"Device with ID {device_id} not found.")
@@ -767,12 +658,13 @@ class PrepReq:
         self,
         method: str,
         url: str,
+        full_url: bool = False,
         params=None,
         data=None,
         headers=None,
     ) -> dict:
         """Make a request to the PetKit API."""
-        _url = "/".join(s.strip("/") for s in [self.base_url, url])
+        _url = url if full_url else "/".join(s.strip("/") for s in [self.base_url, url])
         _headers = {**self.base_headers, **(headers or {})}
         _LOGGER.debug("Request: %s %s", method, _url)
         try:
@@ -798,12 +690,14 @@ class PrepReq:
             ) from e
 
         try:
-            response_json = await response.json()
+            if response.content_type == "application/json":
+                response_json = await response.json()
+            else:
+                return {RES_KEY: await response.text()}
         except ContentTypeError:
             raise PetkitInvalidResponseFormat(
                 "Response is not in JSON format"
             ) from None
-
         # Check for errors in the response
         if ERR_KEY in response_json:
             error_code = int(response_json[ERR_KEY].get("code", 0))
@@ -817,9 +711,7 @@ class PrepReq:
                         f"Authentication failed: {error_msg}"
                     )
                 case 125:
-                    raise PetkitAuthenticationUnregisteredEmailError(
-                        f"Authentication failed: {error_msg}"
-                    )
+                    raise PetkitAuthenticationUnregisteredEmailError
                 case _:
                     raise PypetkitError(
                         f"Request failed code : {error_code}, details : {error_msg} url : {url}"

pypetkitapi/command.py

@@ -9,7 +9,6 @@ import json
 from pypetkitapi.const import (
     ALL_DEVICES,
     D3,
-    D4,
     D4H,
     D4S,
     D4SH,
@@ -145,25 +144,28 @@ class CmdData:
 
 def get_endpoint_manual_feed(device):
     """Get the endpoint for the device"""
-    if device.device_nfo.device_type == FEEDER_MINI:
-        return PetkitEndpoint.MANUAL_FEED_MINI
-    if device.device_nfo.device_type == FEEDER:
-        return PetkitEndpoint.MANUAL_FEED_FRESH_ELEMENT
-    return PetkitEndpoint.MANUAL_FEED_DUAL
+    if device.device_nfo.device_type in [FEEDER_MINI, FEEDER]:
+        return PetkitEndpoint.MANUAL_FEED_OLD  # Old endpoint snakecase
+    return PetkitEndpoint.MANUAL_FEED_NEW  # New endpoint camelcase
 
 
 def get_endpoint_reset_desiccant(device):
+    """Get the endpoint for the device"""
+    if device.device_nfo.device_type in [FEEDER_MINI, FEEDER]:
+        return PetkitEndpoint.DESICCANT_RESET_OLD  # Old endpoint snakecase
+    return PetkitEndpoint.DESICCANT_RESET_NEW  # New endpoint camelcase
+
+
+def get_endpoint_update_setting(device):
     """Get the endpoint for the device"""
     if device.device_nfo.device_type == FEEDER_MINI:
-        return PetkitEndpoint.MINI_DESICCANT_RESET
-    if device.device_nfo.device_type == FEEDER:
-        return PetkitEndpoint.FRESH_ELEMENT_DESICCANT_RESET
-    return PetkitEndpoint.DESICCANT_RESET
+        return PetkitEndpoint.UPDATE_SETTING_FEEDER_MINI
+    return PetkitEndpoint.UPDATE_SETTING
 
 
 ACTIONS_MAP = {
     DeviceCommand.UPDATE_SETTING: CmdData(
-        endpoint=PetkitEndpoint.UPDATE_SETTING,
+        endpoint=lambda device: get_endpoint_update_setting(device),
         params=lambda device, setting: {
             "id": device.id,
             "kv": json.dumps(setting),
@@ -199,16 +201,6 @@ ACTIONS_MAP = {
     ),
     FeederCommand.MANUAL_FEED: CmdData(
         endpoint=lambda device: get_endpoint_manual_feed(device),
-        params=lambda device, setting: {
-            "day": datetime.datetime.now().strftime("%Y%m%d"),
-            "deviceId": device.id,
-            "time": "-1",
-            **setting,
-        },
-        supported_device=[FEEDER, FEEDER_MINI, D3, D4, D4H],
-    ),
-    FeederCommand.MANUAL_FEED_DUAL: CmdData(
-        endpoint=PetkitEndpoint.MANUAL_FEED_DUAL,
         params=lambda device, setting: {
             "day": datetime.datetime.now().strftime("%Y%m%d"),
             "deviceId": device.id,
@@ -216,7 +208,7 @@ ACTIONS_MAP = {
             "time": "-1",
             **setting,
         },
-        supported_device=[D4S, D4SH],
+        supported_device=DEVICES_FEEDER,
     ),
     FeederCommand.CANCEL_MANUAL_FEED: CmdData(
         endpoint=lambda device: (

pypetkitapi/const.py

@@ -34,12 +34,18 @@ K2 = "k2"
 K3 = "k3"
 PET = "pet"
 
+# Litter
 DEVICES_LITTER_BOX = [T3, T4, T5, T6]
 LITTER_WITH_CAMERA = [T5, T6]
 LITTER_NO_CAMERA = [T3, T4]
+# Feeder
+FEEDER_WITH_CAMERA = [D4H, D4SH]
 DEVICES_FEEDER = [FEEDER, FEEDER_MINI, D3, D4, D4S, D4H, D4SH]
+# Water Fountain
 DEVICES_WATER_FOUNTAIN = [W5, CTW3]
+# Purifier
 DEVICES_PURIFIER = [K2]
+# All devices
 ALL_DEVICES = [
     *DEVICES_LITTER_BOX,
     *DEVICES_FEEDER,
@@ -93,6 +99,20 @@ LOGIN_DATA = {
 }
 
 
+class MediaType(StrEnum):
+    """Record Type constants"""
+
+    VIDEO = "avi"
+    IMAGE = "jpg"
+
+
+class VideoType(StrEnum):
+    """Record Type constants"""
+
+    HIGHLIGHT = "highlight"
+    PLAYBACK = "playback"
+
+
 class RecordType(StrEnum):
     """Record Type constants"""
 
@@ -100,9 +120,16 @@ class RecordType(StrEnum):
     FEED = "feed"
     MOVE = "move"
     PET = "pet"
+    TOILETING = "toileting"
 
 
-RecordTypeLST = [RecordType.EAT, RecordType.FEED, RecordType.MOVE, RecordType.PET]
+RecordTypeLST = [
+    RecordType.EAT,
+    RecordType.FEED,
+    RecordType.MOVE,
+    RecordType.PET,
+    RecordType.TOILETING,
+]
 
 
 class PetkitEndpoint(StrEnum):
@@ -121,6 +148,7 @@ class PetkitEndpoint(StrEnum):
     GET_DEVICE_RECORD = "getDeviceRecord"
     GET_DEVICE_RECORD_RELEASE = "getDeviceRecordRelease"
     UPDATE_SETTING = "updateSettings"
+    UPDATE_SETTING_FEEDER_MINI = "update"
 
     # Bluetooth
     BLE_AS_RELAY = "ble/ownSupportBleDevices"
@@ -140,25 +168,30 @@ class PetkitEndpoint(StrEnum):
     GET_PET_OUT_GRAPH = "getPetOutGraph"
 
     # Video features
+    GET_M3U8 = "getM3u8"
     CLOUD_VIDEO = "cloud/video"
     GET_DOWNLOAD_M3U8 = "getDownloadM3u8"
-    GET_M3U8 = "getM3u8"
 
     # Feeders
     REPLENISHED_FOOD = "added"
     FRESH_ELEMENT_CALIBRATION = "food_reset"
     FRESH_ELEMENT_CANCEL_FEED = "cancel_realtime_feed"
-    DESICCANT_RESET = "desiccantReset"
-    MINI_DESICCANT_RESET = "feedermini/desiccant_reset"
-    FRESH_ELEMENT_DESICCANT_RESET = "feeder/desiccant_reset"
+    DESICCANT_RESET_OLD = "desiccant_reset"
+    DESICCANT_RESET_NEW = "desiccantReset"
     CALL_PET = "callPet"
     CANCEL_FEED = "cancelRealtimeFeed"
-    MANUAL_FEED_MINI = "feedermini/save_dailyfeed"
-    MANUAL_FEED_FRESH_ELEMENT = "feeder/save_dailyfeed"
-    MANUAL_FEED_DUAL = "saveDailyFeed"
+    MANUAL_FEED_OLD = "save_dailyfeed"  # For Feeder/FeederMini
+    MANUAL_FEED_NEW = "saveDailyFeed"  # For all other feeders
     DAILY_FEED_AND_EAT = "dailyFeedAndEat"  # D3
     FEED_STATISTIC = "feedStatistic"  # D4
     DAILY_FEED = "dailyFeeds"  # D4S
     REMOVE_DAILY_FEED = "removeDailyFeed"
     RESTORE_DAILY_FEED = "restoreDailyFeed"
     SAVE_FEED = "saveFeed"  # For Feeding plan
+
+    # Schedule
+    SCHEDULE = "schedule/schedules"
+    SCHEDULE_SAVE = "schedule/save"
+    SCHEDULE_REMOVE = "schedule/remove"
+    SCHEDULE_COMPLETE = "schedule/complete"
+    SCHEDULE_HISTORY = "schedule/userHistorySchedules"