uiprotect 0.1.0__py3-none-any.whl

uiprotect/cli/chimes.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+import typer
+
+from uiprotect.api import ProtectApiClient
+from uiprotect.cli import base
+from uiprotect.data import Chime
+
+app = typer.Typer(rich_markup_mode="rich")
+
+ARG_DEVICE_ID = typer.Argument(None, help="ID of chime to select for subcommands")
+ARG_REPEAT = typer.Argument(..., help="Repeat times count", min=1, max=6)
+ARG_VOLUME = typer.Argument(..., help="Volume", min=1, max=100)
+
+
+@dataclass
+class ChimeContext(base.CliContext):
+    devices: dict[str, Chime]
+    device: Chime | None = None
+
+
+ALL_COMMANDS, DEVICE_COMMANDS = base.init_common_commands(app)
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context, device_id: Optional[str] = ARG_DEVICE_ID) -> None:
+    """
+    Chime device CLI.
+
+    Returns full list of Chimes without any arguments passed.
+    """
+    protect: ProtectApiClient = ctx.obj.protect
+    context = ChimeContext(
+        protect=ctx.obj.protect,
+        device=None,
+        devices=protect.bootstrap.chimes,
+        output_format=ctx.obj.output_format,
+    )
+    ctx.obj = context
+
+    if device_id is not None and device_id not in ALL_COMMANDS:
+        if (device := protect.bootstrap.chimes.get(device_id)) is None:
+            typer.secho("Invalid chime ID", fg="red")
+            raise typer.Exit(1)
+        ctx.obj.device = device
+
+    if not ctx.invoked_subcommand:
+        if device_id in ALL_COMMANDS:
+            ctx.invoke(ALL_COMMANDS[device_id], ctx)
+            return
+
+        if ctx.obj.device is not None:
+            base.print_unifi_obj(ctx.obj.device, ctx.obj.output_format)
+            return
+
+        base.print_unifi_dict(ctx.obj.devices)
+
+
+@app.command()
+def cameras(
+    ctx: typer.Context,
+    camera_ids: list[str] = typer.Argument(
+        None,
+        help="Set to [] to empty list of cameras",
+    ),
+    add: bool = typer.Option(False, "-a", "--add", help="Add cameras instead of set"),
+    remove: bool = typer.Option(
+        False,
+        "-r",
+        "--remove",
+        help="Remove cameras instead of set",
+    ),
+) -> None:
+    """Returns or sets paired doorbells for the chime."""
+    base.require_device_id(ctx)
+    obj: Chime = ctx.obj.device
+
+    if add and remove:
+        typer.secho("Add and remove are mutally exclusive", fg="red")
+        raise typer.Exit(1)
+
+    if len(camera_ids) == 0:
+        base.print_unifi_list(obj.cameras)
+        return
+
+    protect: ProtectApiClient = ctx.obj.protect
+
+    if len(camera_ids) == 1 and camera_ids[0] == "[]":
+        camera_ids = []
+
+    for camera_id in camera_ids:
+        if (camera := protect.bootstrap.cameras.get(camera_id)) is None:
+            typer.secho(f"Invalid camera ID: {camera_id}", fg="red")
+            raise typer.Exit(1)
+
+        if not camera.feature_flags.is_doorbell:
+            typer.secho(f"Camera is not a doorbell: {camera_id}", fg="red")
+            raise typer.Exit(1)
+
+    if add:
+        camera_ids = list(set(obj.camera_ids) | set(camera_ids))
+    elif remove:
+        camera_ids = list(set(obj.camera_ids) - set(camera_ids))
+
+    data_before_changes = obj.dict_with_excludes()
+    obj.camera_ids = camera_ids
+    base.run(ctx, obj.save_device(data_before_changes))
+
+
+@app.command()
+def set_volume(
+    ctx: typer.Context,
+    value: int = ARG_VOLUME,
+    camera_id: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--camera",
+        help="Camera ID to apply volume to",
+    ),
+) -> None:
+    """Set volume level for chime rings."""
+    base.require_device_id(ctx)
+    obj: Chime = ctx.obj.device
+    if camera_id is None:
+        base.run(ctx, obj.set_volume(value))
+    else:
+        protect: ProtectApiClient = ctx.obj.protect
+        camera = protect.bootstrap.cameras.get(camera_id)
+        if camera is None:
+            typer.secho(f"Invalid camera ID: {camera_id}", fg="red")
+            raise typer.Exit(1)
+        base.run(ctx, obj.set_volume_for_camera(camera, value))
+
+
+@app.command()
+def play(
+    ctx: typer.Context,
+    volume: Optional[int] = typer.Option(None, "-v", "--volume", min=1, max=100),
+    repeat_times: Optional[int] = typer.Option(None, "-r", "--repeat", min=1, max=6),
+) -> None:
+    """Plays chime tone."""
+    base.require_device_id(ctx)
+    obj: Chime = ctx.obj.device
+    base.run(ctx, obj.play(volume=volume, repeat_times=repeat_times))
+
+
+@app.command()
+def play_buzzer(ctx: typer.Context) -> None:
+    """Plays chime buzzer."""
+    base.require_device_id(ctx)
+    obj: Chime = ctx.obj.device
+    base.run(ctx, obj.play_buzzer())
+
+
+@app.command()
+def set_repeat_times(
+    ctx: typer.Context,
+    value: int = ARG_REPEAT,
+    camera_id: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--camera",
+        help="Camera ID to apply repeat times to",
+    ),
+) -> None:
+    """Set number of times for a chime to repeat when doorbell is rang."""
+    base.require_device_id(ctx)
+    obj: Chime = ctx.obj.device
+    if camera_id is None:
+        base.run(ctx, obj.set_repeat_times(value))
+    else:
+        protect: ProtectApiClient = ctx.obj.protect
+        camera = protect.bootstrap.cameras.get(camera_id)
+        if camera is None:
+            typer.secho(f"Invalid camera ID: {camera_id}", fg="red")
+            raise typer.Exit(1)
+        base.run(ctx, obj.set_repeat_times_for_camera(camera, value))

uiprotect/cli/doorlocks.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Optional
+
+import typer
+
+from uiprotect.api import ProtectApiClient
+from uiprotect.cli import base
+from uiprotect.data import Doorlock
+
+app = typer.Typer(rich_markup_mode="rich")
+
+ARG_DEVICE_ID = typer.Argument(None, help="ID of doorlock to select for subcommands")
+
+
+@dataclass
+class DoorlockContext(base.CliContext):
+    devices: dict[str, Doorlock]
+    device: Doorlock | None = None
+
+
+ALL_COMMANDS, DEVICE_COMMANDS = base.init_common_commands(app)
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context, device_id: Optional[str] = ARG_DEVICE_ID) -> None:
+    """
+    Doorlock device CLI.
+
+    Returns full list of Doorlocks without any arguments passed.
+    """
+    protect: ProtectApiClient = ctx.obj.protect
+    context = DoorlockContext(
+        protect=ctx.obj.protect,
+        device=None,
+        devices=protect.bootstrap.doorlocks,
+        output_format=ctx.obj.output_format,
+    )
+    ctx.obj = context
+
+    if device_id is not None and device_id not in ALL_COMMANDS:
+        if (device := protect.bootstrap.doorlocks.get(device_id)) is None:
+            typer.secho("Invalid doorlock ID", fg="red")
+            raise typer.Exit(1)
+        ctx.obj.device = device
+
+    if not ctx.invoked_subcommand:
+        if device_id in ALL_COMMANDS:
+            ctx.invoke(ALL_COMMANDS[device_id], ctx)
+            return
+
+        if ctx.obj.device is not None:
+            base.print_unifi_obj(ctx.obj.device, ctx.obj.output_format)
+            return
+
+        base.print_unifi_dict(ctx.obj.devices)
+
+
+@app.command()
+def camera(ctx: typer.Context, camera_id: Optional[str] = typer.Argument(None)) -> None:
+    """Returns or sets tha paired camera for a doorlock."""
+    base.require_device_id(ctx)
+    obj: Doorlock = ctx.obj.device
+
+    if camera_id is None:
+        base.print_unifi_obj(obj.camera, ctx.obj.output_format)
+    else:
+        protect: ProtectApiClient = ctx.obj.protect
+        if (camera_obj := protect.bootstrap.cameras.get(camera_id)) is None:
+            typer.secho("Invalid camera ID")
+            raise typer.Exit(1)
+        base.run(ctx, obj.set_paired_camera(camera_obj))
+
+
+@app.command()
+def set_status_light(ctx: typer.Context, enabled: bool) -> None:
+    """Sets status light for the lock."""
+    base.require_device_id(ctx)
+    obj: Doorlock = ctx.obj.device
+
+    base.run(ctx, obj.set_status_light(enabled))
+
+
+@app.command()
+def set_auto_close_time(
+    ctx: typer.Context,
+    duration: int = typer.Argument(..., min=0, max=3600),
+) -> None:
+    """Sets auto-close time for the lock (in seconds). 0 = disabled."""
+    base.require_device_id(ctx)
+    obj: Doorlock = ctx.obj.device
+
+    base.run(ctx, obj.set_auto_close_time(timedelta(seconds=duration)))
+
+
+@app.command()
+def unlock(ctx: typer.Context) -> None:
+    """Unlocks the lock."""
+    base.require_device_id(ctx)
+    obj: Doorlock = ctx.obj.device
+    base.run(ctx, obj.open_lock())
+
+
+@app.command()
+def lock(ctx: typer.Context) -> None:
+    """Locks the lock."""
+    base.require_device_id(ctx)
+    obj: Doorlock = ctx.obj.device
+    base.run(ctx, obj.close_lock())
+
+
+@app.command()
+def calibrate(ctx: typer.Context, force: bool = base.OPTION_FORCE) -> None:
+    """
+    Calibrate the doorlock.
+
+    Door must be open and lock unlocked.
+    """
+    base.require_device_id(ctx)
+    obj: Doorlock = ctx.obj.device
+
+    if force or typer.confirm("Is the door open and unlocked?"):
+        base.run(ctx, obj.calibrate())

uiprotect/cli/events.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.progress import Progress
+
+from uiprotect import data as d
+from uiprotect.api import ProtectApiClient
+from uiprotect.cli import base
+from uiprotect.exceptions import NvrError
+from uiprotect.utils import local_datetime
+
+app = typer.Typer(rich_markup_mode="rich")
+
+ARG_EVENT_ID = typer.Argument(None, help="ID of camera to select for subcommands")
+OPTION_START = typer.Option(None, "-s", "--start")
+OPTION_END = typer.Option(None, "-e", "--end")
+OPTION_LIMIT = typer.Option(None, "-l", "--limit")
+OPTION_OFFSET = typer.Option(None, "-o", "--offet")
+OPTION_TYPES = typer.Option(None, "-t", "--type")
+OPTION_SMART_TYPES = typer.Option(
+    None,
+    "-d",
+    "--smart-detect",
+    help="If provided, will only return smartDetectZone events",
+)
+
+
+@dataclass
+class EventContext(base.CliContext):
+    events: dict[str, d.Event] | None = None
+    event: d.Event | None = None
+
+
+ALL_COMMANDS: dict[str, Callable[..., None]] = {}
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    event_id: Optional[str] = ARG_EVENT_ID,
+    start: Optional[datetime] = OPTION_START,
+    end: Optional[datetime] = OPTION_END,
+    limit: Optional[int] = OPTION_LIMIT,
+    offset: Optional[int] = OPTION_OFFSET,
+    types: Optional[list[d.EventType]] = OPTION_TYPES,
+    smart_types: Optional[list[d.SmartDetectObjectType]] = OPTION_SMART_TYPES,
+) -> None:
+    """
+    Events CLI.
+
+    Returns list of events from the last 24 hours without any arguments passed.
+    """
+    protect: ProtectApiClient = ctx.obj.protect
+    context = EventContext(
+        protect=ctx.obj.protect,
+        event=None,
+        events=None,
+        output_format=ctx.obj.output_format,
+    )
+    ctx.obj = context
+
+    if event_id is not None and event_id not in ALL_COMMANDS:
+        try:
+            ctx.obj.event = base.run(ctx, protect.get_event(event_id))
+        except NvrError as err:
+            typer.secho("Invalid event ID", fg="red")
+            raise typer.Exit(1) from err
+
+    if not ctx.invoked_subcommand:
+        if ctx.obj.event is not None:
+            base.print_unifi_obj(ctx.obj.event, ctx.obj.output_format)
+            return
+
+        if types is not None and len(types) == 0:
+            types = None
+        if smart_types is not None and len(smart_types) == 0:
+            smart_types = None
+        events = base.run(
+            ctx,
+            protect.get_events(
+                start=start,
+                end=end,
+                limit=limit,
+                offset=offset,
+                types=types,
+                smart_detect_types=smart_types,
+            ),
+        )
+        ctx.obj.events = {}
+        for event in events:
+            ctx.obj.events[event.id] = event
+
+        if event_id in ALL_COMMANDS:
+            ctx.invoke(ALL_COMMANDS[event_id], ctx)
+            return
+
+        base.print_unifi_dict(ctx.obj.events)
+
+
+def require_event_id(ctx: typer.Context) -> None:
+    """Requires event ID in context"""
+    if ctx.obj.event is None:
+        typer.secho("Requires a valid event ID to be selected")
+        raise typer.Exit(1)
+
+
+def require_no_event_id(ctx: typer.Context) -> None:
+    """Requires no device ID in context"""
+    if ctx.obj.event is not None or ctx.obj.events is None:
+        typer.secho("Requires no event ID to be selected")
+        raise typer.Exit(1)
+
+
+@app.command()
+def list_ids(ctx: typer.Context) -> None:
+    """
+    Prints list of "id type timestamp" for each event.
+
+    Timestamps dispalyed in your locale timezone. If it is not configured
+    correctly, it will default to UTC. You can override your timezone with
+    the TZ environment variable.
+    """
+    require_no_event_id(ctx)
+    objs: dict[str, d.Event] = ctx.obj.events
+    to_print: list[tuple[str, str, datetime]] = []
+    longest_event = 0
+    for obj in objs.values():
+        event_type = obj.type.value
+        if event_type in {
+            d.EventType.SMART_DETECT.value,
+            d.EventType.SMART_DETECT_LINE.value,
+        }:
+            event_type = f"{event_type}[{','.join(obj.smart_detect_types)}]"
+        longest_event = max(len(event_type), longest_event)
+        dt = obj.timestamp or obj.start
+        dt = local_datetime(dt)
+
+        to_print.append((obj.id, event_type, dt))
+
+    if ctx.obj.output_format == base.OutputFormatEnum.JSON:
+        base.json_output(to_print)
+    else:
+        for item in to_print:
+            typer.echo(f"{item[0]}\t{item[1]:{longest_event}}\t{item[2]}")
+
+
+ALL_COMMANDS["list-ids"] = list_ids
+
+
+@app.command()
+def save_thumbnail(
+    ctx: typer.Context,
+    output_path: Path = typer.Argument(..., help="JPEG format"),
+) -> None:
+    """
+    Saves thumbnail for event.
+
+    Only for ring, motion and smartDetectZone events.
+    """
+    require_event_id(ctx)
+    event: d.Event = ctx.obj.event
+
+    thumbnail = base.run(ctx, event.get_thumbnail())
+    if thumbnail is None:
+        typer.secho("Could not get thumbnail", fg="red")
+        raise typer.Exit(1)
+
+    Path(output_path).write_bytes(thumbnail)
+
+
+@app.command()
+def save_animated_thumbnail(
+    ctx: typer.Context,
+    output_path: Path = typer.Argument(..., help="GIF format"),
+) -> None:
+    """
+    Saves animated thumbnail for event.
+
+    Only for ring, motion and smartDetectZone events.
+    """
+    require_event_id(ctx)
+    event: d.Event = ctx.obj.event
+
+    thumbnail = base.run(ctx, event.get_animated_thumbnail())
+    if thumbnail is None:
+        typer.secho("Could not get thumbnail", fg="red")
+        raise typer.Exit(1)
+
+    Path(output_path).write_bytes(thumbnail)
+
+
+@app.command()
+def save_heatmap(
+    ctx: typer.Context,
+    output_path: Path = typer.Argument(..., help="PNG format"),
+) -> None:
+    """
+    Saves heatmap for event.
+
+    Only motion events have heatmaps.
+    """
+    require_event_id(ctx)
+    event: d.Event = ctx.obj.event
+
+    heatmap = base.run(ctx, event.get_heatmap())
+    if heatmap is None:
+        typer.secho("Could not get heatmap", fg="red")
+        raise typer.Exit(1)
+
+    Path(output_path).write_bytes(heatmap)
+
+
+@app.command()
+def save_video(
+    ctx: typer.Context,
+    output_path: Path = typer.Argument(..., help="MP4 format"),
+    channel: int = typer.Option(
+        0,
+        "-c",
+        "--channel",
+        min=0,
+        max=3,
+        help="0 = High, 1 = Medium, 2 = Low, 3 = Package",
+    ),
+) -> None:
+    """
+    Exports video for event.
+
+    Only for ring, motion and smartDetectZone events.
+    """
+    require_event_id(ctx)
+    event: d.Event = ctx.obj.event
+
+    with Progress() as pb:
+        task_id = pb.add_task("(1/2) Exporting", total=100)
+
+        async def callback(step: int, current: int, total: int) -> None:
+            pb.update(
+                task_id,
+                total=total,
+                completed=current,
+                description="(2/2) Downloading",
+            )
+
+        base.run(
+            ctx,
+            event.get_video(
+                channel,
+                output_file=output_path,
+                progress_callback=callback,
+            ),
+        )

uiprotect/cli/lights.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Optional
+
+import typer
+
+from uiprotect.api import ProtectApiClient
+from uiprotect.cli import base
+from uiprotect.data import Light
+
+app = typer.Typer(rich_markup_mode="rich")
+
+ARG_DEVICE_ID = typer.Argument(None, help="ID of light to select for subcommands")
+
+
+@dataclass
+class LightContext(base.CliContext):
+    devices: dict[str, Light]
+    device: Light | None = None
+
+
+ALL_COMMANDS, DEVICE_COMMANDS = base.init_common_commands(app)
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context, device_id: Optional[str] = ARG_DEVICE_ID) -> None:
+    """
+    Lights device CLI.
+
+    Returns full list of Viewers without any arguments passed.
+    """
+    protect: ProtectApiClient = ctx.obj.protect
+    context = LightContext(
+        protect=ctx.obj.protect,
+        device=None,
+        devices=protect.bootstrap.lights,
+        output_format=ctx.obj.output_format,
+    )
+    ctx.obj = context
+
+    if device_id is not None and device_id not in ALL_COMMANDS:
+        if (device := protect.bootstrap.lights.get(device_id)) is None:
+            typer.secho("Invalid light ID", fg="red")
+            raise typer.Exit(1)
+        ctx.obj.device = device
+
+    if not ctx.invoked_subcommand:
+        if device_id in ALL_COMMANDS:
+            ctx.invoke(ALL_COMMANDS[device_id], ctx)
+            return
+
+        if ctx.obj.device is not None:
+            base.print_unifi_obj(ctx.obj.device, ctx.obj.output_format)
+            return
+
+        base.print_unifi_dict(ctx.obj.devices)
+
+
+@app.command()
+def camera(ctx: typer.Context, camera_id: Optional[str] = typer.Argument(None)) -> None:
+    """Returns or sets tha paired camera for a light."""
+    base.require_device_id(ctx)
+    obj: Light = ctx.obj.device
+
+    if camera_id is None:
+        base.print_unifi_obj(obj.camera, ctx.obj.output_format)
+    else:
+        protect: ProtectApiClient = ctx.obj.protect
+        if (camera_obj := protect.bootstrap.cameras.get(camera_id)) is None:
+            typer.secho("Invalid camera ID")
+            raise typer.Exit(1)
+        base.run(ctx, obj.set_paired_camera(camera_obj))
+
+
+@app.command()
+def set_status_light(ctx: typer.Context, enabled: bool) -> None:
+    """Sets status light for light device."""
+    base.require_device_id(ctx)
+    obj: Light = ctx.obj.device
+
+    base.run(ctx, obj.set_status_light(enabled))
+
+
+@app.command()
+def set_led_level(
+    ctx: typer.Context,
+    led_level: int = typer.Argument(..., min=1, max=6),
+) -> None:
+    """Sets brightness of LED on light."""
+    base.require_device_id(ctx)
+    obj: Light = ctx.obj.device
+
+    base.run(ctx, obj.set_led_level(led_level))
+
+
+@app.command()
+def set_sensitivity(
+    ctx: typer.Context,
+    sensitivity: int = typer.Argument(..., min=0, max=100),
+) -> None:
+    """Sets motion sensitivity for the light."""
+    base.require_device_id(ctx)
+    obj: Light = ctx.obj.device
+
+    base.run(ctx, obj.set_sensitivity(sensitivity))
+
+
+@app.command()
+def set_duration(
+    ctx: typer.Context,
+    duration: int = typer.Argument(..., min=15, max=900),
+) -> None:
+    """Sets timeout duration (in seconds) for light."""
+    base.require_device_id(ctx)
+    obj: Light = ctx.obj.device
+
+    base.run(ctx, obj.set_duration(timedelta(seconds=duration)))