pycatlink 1.0.0__py3-none-any.whl

pycatlink/__init__.py

@@ -0,0 +1 @@
+"""CatLink API Library."""

pycatlink/__main__.py

@@ -0,0 +1,252 @@
+import asyncio
+from collections.abc import Callable, Coroutine
+from functools import wraps
+from typing import Any, ParamSpec, TypeVar
+
+import typer
+from dotenv import load_dotenv
+
+from pycatlink.c08 import CatlinkC08Device
+from pycatlink.client import CatlinkApiClient
+
+from .account import CatlinkAccount
+from .const import (
+    ENV_CATLINK_PASSWORD,
+    ENV_CATLINK_PHONE,
+    ENV_CATLINK_PHONE_INTERNATIONAL_CODE,
+    HttpMethod,
+)
+from .models import CatlinkAccountConfig
+
+app = typer.Typer()
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def syncify(f: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, R]:
+    """Decorator to convert async function to sync by running with asyncio.run."""
+
+    @wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        return asyncio.run(f(*args, **kwargs))
+
+    return wrapper
+
+
+@app.command("fetch")
+@syncify
+async def api_fetch(
+    phone: str = typer.Option(
+        ...,
+        help="Catlink account phone number (not starting with 0 or country code).",
+        envvar=ENV_CATLINK_PHONE,
+    ),
+    password: str = typer.Option(
+        ...,
+        help="Catlink account password.",
+        envvar=ENV_CATLINK_PASSWORD,
+    ),
+    phone_international_code: str = typer.Option(
+        ...,
+        help="Catlink account phone international code.",
+        envvar=ENV_CATLINK_PHONE_INTERNATIONAL_CODE,
+    ),
+    path: str = typer.Option(
+        ...,
+        help="API path to fetch data from.",
+    ),
+    parameters: str = typer.Option(
+        "",
+        help="Query parameters in key1=value1&key2=value2 format.",
+    ),
+) -> None:
+    """GET Request to the Catlink API."""
+
+    config = CatlinkAccountConfig(
+        phone=phone,
+        password=password,
+        phone_international_code=phone_international_code,
+    )
+    client = CatlinkApiClient(config)
+
+    parameters_dict: dict[str, str] = {}
+    if parameters:
+        for pair in parameters.split("&"):
+            if "=" in pair:
+                key, value = pair.split("=", 1)
+                parameters_dict[key] = value
+
+    response = await client.request_with_auto_login(
+        path=path,
+        parameters=parameters_dict,
+        method=HttpMethod.GET,
+    )
+
+    typer.echo("Response:")
+    typer.echo(response)
+
+
+@app.command()
+@syncify
+async def pets(
+    phone: str = typer.Option(
+        ...,
+        help="Catlink account phone number (not starting with 0 or country code).",
+        envvar=ENV_CATLINK_PHONE,
+    ),
+    password: str = typer.Option(
+        ...,
+        help="Catlink account password.",
+        envvar=ENV_CATLINK_PASSWORD,
+    ),
+    phone_international_code: str = typer.Option(
+        ...,
+        help="Catlink account phone international code.",
+        envvar=ENV_CATLINK_PHONE_INTERNATIONAL_CODE,
+    ),
+) -> None:
+    """Print the list of pets associated with the account."""
+
+    config = CatlinkAccountConfig(
+        phone=phone,
+        password=password,
+        phone_international_code=phone_international_code,
+    )
+
+    account = CatlinkAccount(config)
+
+    typer.echo("Fetching pets...")
+
+    pets = await account.get_pets()
+
+    typer.echo(f"Found {len(pets)} pet(s)")
+
+    for i, pet in enumerate(pets):
+        typer.echo(f"Pet {i + 1}")
+        typer.echo(pet)
+
+
+@app.command()
+@syncify
+async def devices(
+    phone: str = typer.Option(
+        ...,
+        help="Catlink account phone number (not starting with 0 or country code).",
+        envvar=ENV_CATLINK_PHONE,
+    ),
+    password: str = typer.Option(
+        ...,
+        help="Catlink account password.",
+        envvar=ENV_CATLINK_PASSWORD,
+    ),
+    phone_international_code: str = typer.Option(
+        ...,
+        help="Catlink account phone international code.",
+        envvar=ENV_CATLINK_PHONE_INTERNATIONAL_CODE,
+    ),
+) -> None:
+    """Print the list of devices associated with the account."""
+
+    config = CatlinkAccountConfig(
+        phone=phone,
+        password=password,
+        phone_international_code=phone_international_code,
+    )
+
+    account = CatlinkAccount(config)
+
+    typer.echo("Fetching devices...")
+
+    devices = await account.get_devices()
+
+    typer.echo(f"Found {len(devices)} device(s)")
+
+    for i, device in enumerate(devices):
+        typer.echo(f"Device {i + 1}")
+        typer.echo(device.device_info)
+
+
+@app.command()
+@syncify
+async def device(
+    phone: str = typer.Option(
+        ...,
+        help="Catlink account phone number (not starting with 0 or country code).",
+        envvar=ENV_CATLINK_PHONE,
+    ),
+    password: str = typer.Option(
+        ...,
+        help="Catlink account password.",
+        envvar=ENV_CATLINK_PASSWORD,
+    ),
+    phone_international_code: str = typer.Option(
+        ...,
+        help="Catlink account phone international code.",
+        envvar=ENV_CATLINK_PHONE_INTERNATIONAL_CODE,
+    ),
+    device_id: str = typer.Argument(
+        ...,
+        help="ID of the device to get details for.",
+    ),
+) -> None:
+    """Print detailed information for a specific device."""
+
+    config = CatlinkAccountConfig(
+        phone=phone,
+        password=password,
+        phone_international_code=phone_international_code,
+    )
+
+    account = CatlinkAccount(config)
+
+    typer.echo("Fetching devices...")
+
+    devices = await account.get_devices()
+
+    device = next(
+        (device for device in devices if str(device.device_info.id) == device_id), None
+    )
+    if not device:
+        typer.echo(f"Device with ID {device_id} not found.")
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Refreshing data for device ID {device_id}...")
+
+    await device.refresh()
+
+    typer.echo(f"Info for device ID {device_id}:")
+    typer.echo(device.device_info)
+
+    if not isinstance(device, (CatlinkC08Device,)):
+        typer.echo("Detailed information fetching is only supported for C08 devices.")
+        raise typer.Exit(code=0)
+
+    typer.echo(f"Details for device ID {device_id}:")
+    typer.echo(device.device_details)
+
+    typer.echo(f"Stats for device ID {device_id}:")
+    typer.echo(device.device_stats)
+
+    typer.echo(f"Logs for device ID {device_id}:")
+    typer.echo(device.device_logs)
+
+    typer.echo(f"Pet stats for device ID {device_id}:")
+    typer.echo(device.pet_stats)
+
+    typer.echo(f"Linked pets for device ID {device_id}:")
+    typer.echo(device.linked_pets)
+
+    typer.echo(f"Selectable pets for device ID {device_id}:")
+    typer.echo(device.selectable_pets)
+
+    typer.echo(f"Notice configurations for device ID {device_id}:")
+    typer.echo(device.notice_configs)
+
+    typer.echo(f"About device information for device ID {device_id}:")
+    typer.echo(device.about_device)
+
+
+if __name__ == "__main__":
+    load_dotenv()
+    app()

pycatlink/account.py

@@ -0,0 +1,75 @@
+"""Account module for CatLink API."""
+
+from .c08 import CatlinkC08Device
+from .client import CatlinkApiClient
+from .const import (
+    API_DEVICE_LIST,
+    API_PET_LIST,
+    PARAMETER_TYPE,
+    RESPONSE_KEY_DATA,
+    RESPONSE_KEY_DEVICES,
+    RESPONSE_KEY_PETS,
+    RESPONSE_KEY_RECORDS,
+    TYPE_NONE,
+    HttpMethod,
+)
+from .device import CatlinkDevice
+from .models import CatlinkAccountConfig, CatlinkDeviceInfo, CatlinkPet
+
+
+class CatlinkAccount:
+    """Account class for CatLink integration."""
+
+    def __init__(self, config: CatlinkAccountConfig) -> None:
+        """Initialize the account."""
+        self.config = config
+
+        self._client = CatlinkApiClient(config)
+
+    async def get_devices(self) -> list[CatlinkDevice | CatlinkC08Device]:
+        """Get the list of devices associated with the account."""
+        response = await self._client.request_with_auto_login(
+            path=API_DEVICE_LIST,
+            method=HttpMethod.GET,
+            parameters={
+                PARAMETER_TYPE: TYPE_NONE,
+            },
+        )
+        device_infos = [
+            CatlinkDeviceInfo.from_dict(response_element)
+            for response_element in response.get(RESPONSE_KEY_DATA, {}).get(
+                RESPONSE_KEY_DEVICES, []
+            )
+        ]
+
+        return [self._create_device(device_info) for device_info in device_infos]
+
+    async def get_pets(self) -> list[CatlinkPet]:
+        """Get the list of pets associated with the account."""
+        response = await self._client.request_with_auto_login(
+            path=API_PET_LIST,
+            method=HttpMethod.GET,
+            parameters={},
+        )
+        pet_infos = [
+            CatlinkPet.from_dict(response_element)
+            for response_element in response.get(RESPONSE_KEY_DATA, {})
+            .get(RESPONSE_KEY_PETS, {})
+            .get(RESPONSE_KEY_RECORDS, [])
+        ]
+
+        return pet_infos
+
+    def _create_device(
+        self, device_info: CatlinkDeviceInfo
+    ) -> CatlinkDevice | CatlinkC08Device:
+        """Create the appropriate device instance based on device type."""
+        if not device_info.device_type:
+            return CatlinkDevice(device_info, self._client)
+
+        device_type_upper = device_info.device_type.upper()
+
+        if device_type_upper == "C08":
+            return CatlinkC08Device(device_info, self._client)
+
+        return CatlinkDevice(device_info, self._client)