lid-cli 0.1__py3-none-any.whl

lid/__init__.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""lid-cli."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from types import ModuleType
+
+    from lid import gio, io, subprocess, types
+else:
+
+    def __getattr__(key: str, /) -> ModuleType:
+        if key in __all__:
+            return importlib.import_module(f"{__package__}.{key}", package=__package__)
+        raise AttributeError(f"module `{__name__}` has not attribute `{key}`")
+
+
+__version__ = importlib.metadata.version("lid-cli")
+__all__ = ["__version__", "gio", "io", "subprocess", "types"]

lid/__main__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""CLI entry point."""
+
+from __future__ import annotations
+
+if __name__ == "__main__":
+    pass

lid/cli.py

@@ -0,0 +1,230 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""CLI."""
+
+from __future__ import annotations
+
+import itertools as it
+import logging
+import pathlib as pl
+from typing import Annotated
+
+import rich.console
+import rich.theme
+import typer
+
+import lid
+
+log = logging.getLogger(__name__)
+
+env: lid.types.Environment
+console: rich.console.Console
+
+_HELP = """
+Resource activation and communication helper.
+"""
+
+app = typer.Typer(help=_HELP, no_args_is_help=True, rich_markup_mode="markdown")
+
+
+@app.callback()
+def _setup_io() -> None:
+    global env, console  # noqa: PLW0603
+
+    import logging
+
+    theme = rich.theme.Theme(
+        {
+            "info": "italic yellow",
+            "warning": "italic red",
+            "error": "bold bright_red",
+        }
+    )
+    console = rich.console.Console(
+        theme=theme,
+        # STDOUT is used for piping; formatted output should go to stderr.
+        stderr=True,
+    )
+    try:
+        env = lid.io.capture_environment()
+    except lid.types.EnvCaptureError as err:
+        console.print("Failed to capture environment.", style="error")
+        raise typer.Exit(2) from err
+
+    if env.log_level is None:
+        logging.basicConfig(level=logging.CRITICAL)
+    else:
+        from pathlib import Path
+
+        import msgspec
+
+        logging.basicConfig(
+            filename=Path.cwd() / ".lid.jsonl",
+            encoding="utf-8",
+            level=env.log_level,
+            force=True,
+        )
+
+        _encode_json = msgspec.json.Encoder().encode
+
+        class JsonLineFormatter(logging.Formatter):
+            def format(self, record: logging.LogRecord) -> str:
+                return _encode_json(
+                    {
+                        "time": self.formatTime(record),
+                        "level": record.levelname,
+                        "logger": record.name,
+                        "message": record.getMessage(),
+                    }
+                ).decode("utf-8")
+
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers:
+            handler.setFormatter(JsonLineFormatter())
+
+
+# Use `list` as return value since type must be available at runtime for typer to work.
+# Argument is passed as kwarg by typer.
+def _complete_mount_kw(incomplete: str) -> list[str]:
+    import asyncio
+
+    env = lid.io.capture_environment()
+    return asyncio.run(
+        lid.gio.find_device_names(
+            incomplete, mounted_only=False, env=env, runner=lid.subprocess.run
+        )
+    )
+
+
+def _require_nonempty(param: typer.CallbackParam, v: str | None) -> str | None:
+    if v is None or v:
+        return v
+    raise typer.BadParameter(f"parameter `{param.name}` must not be an empty string")
+
+
+@app.command()
+def mount(
+    kw: Annotated[
+        str,
+        typer.Argument(
+            help="Device keyword.",
+            autocompletion=_complete_mount_kw,
+            callback=_require_nonempty,
+        ),
+    ],
+) -> int:
+    import asyncio
+    import uuid
+
+    import msgspec
+
+    with asyncio.Runner() as runner:
+        try:
+            mt = runner.run(lid.gio.mount(kw, env=env, runner=lid.subprocess.run))
+        except lid.types.GioNotFoundError as err:
+            log.exception("Failed to mount for keyword `%s`.", kw)
+            raise typer.BadParameter(f"Device not determined: {err}.") from None
+        except lid.types.GioMountError as err:
+            log.exception("Failed to mount for keyword `%s`.", kw)
+            console.print(f"Mount failure: {err}.", style="error")
+            raise typer.Exit(2) from None
+
+        console.print(f"Mounted `{mt.name}`.", style="info")
+        if mt.triggered:
+            mt_info = msgspec.json.encode(mt)
+            try:
+                env.runtime_dir.mkdir(parents=True, exist_ok=True)
+                env.runtime_dir.joinpath(str(uuid.uuid4())).write_bytes(mt_info)
+            except OSError, PermissionError:
+                log.exception("Failed to create mount marker file.")
+                try:
+                    runner.run(
+                        lid.gio.umount(mount=mt, env=env, runner=lid.subprocess.run)
+                    )
+                except lid.types.GioMountError as err:
+                    console.print(
+                        f"Failed to create marker file, then failed to umount: {err}.",
+                        style="error",
+                    )
+                    raise typer.Exit(2) from None
+
+    # Needs to be unformatted to not confuse receiver (listening on STDOUT).
+    print(mt.mountpoint)
+    return 0
+
+
+def _complete_umount_kw(incomplete: str) -> list[str]:
+    import asyncio
+
+    env = lid.io.capture_environment()
+    return asyncio.run(
+        lid.gio.find_device_names(
+            incomplete, mounted_only=True, env=env, runner=lid.subprocess.run
+        )
+    )
+
+
+async def _umount(kw: str, /, env: lid.types.Environment) -> int:
+    import asyncio
+
+    names, markers = await asyncio.gather(
+        lid.gio.find_device_names(
+            kw, mounted_only=True, env=env, runner=lid.subprocess.run
+        ),
+        asyncio.to_thread(lid.io.read_mount_markers, env),
+    )
+    match [(p, m) for n, (p, m) in it.product(names, markers) if n == m.name]:
+        case []:
+            log.info("Found no matching marker file. Exiting.")
+            return 0
+        case [[pl.Path() as f, lid.types.Mount() as mt]]:
+            try:
+                await lid.gio.umount(mount=mt, env=env, runner=lid.subprocess.run)
+            except lid.types.GioNotFoundError as err:
+                log.exception("Failed to mount for keyword `%s` (match: `%s`.", kw, mt)
+                raise typer.BadParameter(f"Device not determined: {err}.") from None
+            except lid.types.GioMountError as err:
+                log.exception(
+                    "Failed to unmount for keyword `%s` (match: `%s`).", kw, mt
+                )
+                console.print(f"Unmount failure: {err}.", style="error")
+                raise typer.Exit(2) from None
+
+            console.print(f"Unmounted `{mt.name}`.", style="info")
+
+            try:
+                f.unlink()
+            except OSError, PermissionError:
+                console.print(
+                    f"Failed to remove marker file `{f.as_posix()}`.", style="error"
+                )
+                raise typer.Exit(2) from None
+            return 0
+        case [[pl.Path() as f, fmt], [pl.Path() as s, smt], *m]:
+            raise typer.BadParameter(
+                f"Keyword `{kw}` matches `{fmt.name}` (file:`{f.name}`), "
+                f"`{smt.name}` (file: `{s.name}`), and {len(m)} more."
+            )
+
+    console.print(
+        "Discovered unsupported case. No action will be taken.", style="error"
+    )
+    return 2
+
+
+@app.command()
+def umount(
+    kw: Annotated[
+        str,
+        typer.Argument(
+            help="Device keyword.",
+            autocompletion=_complete_umount_kw,
+            callback=_require_nonempty,
+        ),
+    ],
+) -> int:
+    import asyncio
+
+    env = lid.io.capture_environment()
+    return asyncio.run(_umount(kw, env=env))

lid/gio.py

@@ -0,0 +1,300 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""Parse mount-style indentation based files."""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+
+from lid import types
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from typing import Any, Protocol, cast, overload
+
+    class AsyncRunner(Protocol):
+        async def __call__(
+            self, bin_: str, /, *args: str, env_mods: dict[str, str] | None = None
+        ) -> str: ...
+
+    @overload
+    async def umount(
+        kw: str,
+        /,
+        *,
+        env: types.Environment,
+        runner: AsyncRunner,
+    ) -> None: ...
+    @overload
+    async def umount(
+        *,
+        mount: types.Mount,
+        env: types.Environment,
+        runner: AsyncRunner,
+    ) -> None: ...
+
+
+__all__ = ["find_device_names", "mount", "umount"]
+
+log = logging.getLogger(__name__)
+
+
+# Return type dictated by use a completion suggester.
+async def find_device_names(
+    kw: str, /, mounted_only: bool, env: types.Environment, runner: AsyncRunner
+) -> list[str]:
+    device_info = await _query_matching_device_info(
+        kw, include_details=False, env=env, runner=runner
+    )
+    if not mounted_only:
+        return [d["__name__"] for d in device_info]
+    return [d["__name__"] for d in device_info if any(k.startswith("Mount") for k in d)]
+
+
+async def mount(kw: str, /, env: types.Environment, runner: AsyncRunner) -> types.Mount:
+    """Mount device.
+
+    Parameters
+    ----------
+    kw
+        (Partial) name of device as given in the top line of the gio output section.
+    """
+    device_info = await _query_matching_device_info(
+        kw, include_details=True, env=env, runner=runner
+    )
+    device = _extract_device(kw, device_info=device_info)
+
+    name, mount_id, is_mounted = device.name, device.id_, device.is_mounted
+    if is_mounted:
+        log.info("Device `%s` already mounted.", name)
+    else:
+        log.info("Mounting device `%s`.", name)
+        try:
+            await runner(env.gio_bin, "mount", "--device", mount_id)
+        except types.SubprocessError as err:
+            log.exception("Failed to mount device ID `%s`.", mount_id)
+            raise types.GioMountError(
+                f"failed to mount device with ID`{mount_id}`"
+            ) from err
+
+    try:
+        mp = await _find_mountpoint(mount_id, env=env, runner=runner)
+    except types.GioMountError as err:
+        log.exception("Found no mount point for `%s`.", name)
+        raise types.GioMountError(f"found no mount point for `{name}`") from err
+
+    return types.Mount(name=name, mountpoint=mp, triggered=mount_id is not None)
+
+
+async def umount(
+    kw: str | None = None,
+    /,
+    *,
+    mount: types.Mount | None = None,
+    env: types.Environment,
+    runner: AsyncRunner,
+) -> None:
+    """Unmount device."""
+    if kw is not None:
+        device_info = await _query_matching_device_info(
+            kw, include_details=True, env=env, runner=runner
+        )
+        device = _extract_device(kw, device_info=device_info)
+
+        if not device.is_mounted:
+            log.info("Device `%s` not mounted.")
+            return
+        name, mount_id = device.name, device.id_
+
+        try:
+            mountpoint = await _find_mountpoint(mount_id, env=env, runner=runner)
+        except types.GioMountError as err:
+            log.exception("Found no mount point for `%s`.", name)
+            raise types.GioMountError(f"found no mount point for `{name}`") from err
+    else:
+        if TYPE_CHECKING:
+            mount = cast("types.Mount", mount)
+        mountpoint = mount.mountpoint
+
+    try:
+        await runner(env.gio_bin, "mount", "--unmount", mountpoint)
+    except types.SubprocessError as err:
+        raise types.GioMountError(f"failed to unmount `{mountpoint}`") from err
+
+
+@dataclass(slots=True, kw_only=True)
+class _Device:
+    name: str
+    id_: str
+    is_mounted: bool
+    data: dict[str, Any]
+
+
+async def _query_matching_device_info(
+    kw: str, /, include_details: bool, env: types.Environment, runner: AsyncRunner
+) -> Sequence[dict[str, Any]]:
+    if not kw:
+        raise ValueError("empty keyword cannot be used for device identification")
+
+    if include_details:
+        gio_args = ("mount", "--list", "--detail")
+    else:
+        gio_args = ("mount", "--list")
+    try:
+        gio_out = await runner(env.gio_bin, *gio_args)
+    except types.SubprocessError as err:
+        raise types.GioMountError(
+            "failed to collect gio output for device discovery"
+        ) from err
+    try:
+        info = _parse_output(gio_out)
+    except types.GioParseError as err:
+        raise types.GioMountError(
+            "failed to parse gio output for device discovery"
+        ) from err
+
+    pattern = re.compile(kw, re.IGNORECASE)
+    return [
+        v
+        for k, v in info.items()
+        if k.startswith(("Volume", "Drive"))
+        and isinstance(v, dict)
+        and pattern.search(v.get("__name__", "")) is not None
+    ]
+
+
+def _extract_device(kw: str, /, device_info: Sequence[dict[str, Any]]) -> _Device:
+    match device_info:
+        case []:
+            raise types.GioNotFoundError(f"found no device matching for `{kw}`")
+        case [{"__name__": name} as v]:
+            log.debug("Matched `%s` to full name `%s`.", kw, name)
+
+            is_mounted = any(k_.startswith("Mount") for k_ in v)
+            match v:
+                case {"ids": {"unix-device": str() as mount_id}}:
+                    log.info("Found unix-device `%s`.")
+                case {"ids": {"uuid": str() as mount_id}}:
+                    log.info("Found UUID `%s`.")
+                case _:
+                    log.error("Failed to find mount ID in `%s`.", v)
+                    raise types.GioNotFoundError(f"failed to find ID for `{name}`")
+            return _Device(name=name, id_=mount_id, is_mounted=is_mounted, data=v)
+        case [f, s, *ms]:
+            fn, sn, lms = f["__name__"], s["__name__"], len(ms)
+            raise types.GioNotFoundError(
+                f"found multiple matches for `{kw}`: `{fn}`, `{sn}`, and {lms} more."
+            )
+        case _:
+            raise types.GioNotFoundError("unsupported gio output structure")
+
+
+async def _find_mountpoint(
+    id_: str, /, env: types.Environment, runner: AsyncRunner
+) -> str:
+    try:
+        # Requires device to be mounted.
+        # Need to the US locale as the output key are adapted to that setting.
+        gio_out = await runner(
+            env.gio_bin, "info", "-a", "local", id_, env_mods={"LANG": "en_US-UTF-8"}
+        )
+    except types.SubprocessError as err:
+        raise types.GioMountError(
+            "failed to collect gio output for mountpoint discovery"
+        ) from err
+    try:
+        gio_out = _parse_output(gio_out)
+    except types.GioParseError as err:
+        raise types.GioMountError(
+            "failed to parse gio output for path discovery"
+        ) from err
+
+    return gio_out["local path"]
+
+
+def _parse_output(text: str, /, header_name: str = "__name__") -> dict[str, Any]:
+    content, stack = {}, []
+    for line in text.splitlines():
+        if (line := _parse_line(line)) is None:
+            continue
+
+        if not stack:
+            log.debug("Entering toplevel (indent %s).", line.indent)
+            content[line.key] = line.value
+            stack.append(_SubConfig(indent=line.indent, content=content))
+            continue
+
+        while len(stack) > 1 and line.indent < (prev_indent := stack[-1].indent):
+            log.debug("Leaving level (indent %s).", prev_indent)
+            stack.pop()
+        current = stack[-1]
+        if line.indent < current.indent:
+            raise types.GioParseError(
+                f"indent {line.indent} does not match any previous level"
+            )
+
+        if line.indent > current.indent:
+            log.debug("Entering level (indent %s).", line.indent)
+            # `current.content` is only empty in empty in the first round, wherein
+            # this case cannot occur.
+            prev_k, prev_v = next(reversed(current.content.items()))
+            if prev_v is None:
+                log.debug("Adding %s=%s.", line.key, line.value)
+                current.content[prev_k] = {line.key: line.value}
+            else:
+                log.debug("Adding existing value as header name.")
+                log.debug("Adding %s=%s.", line.key, line.value)
+                current.content[prev_k] = {header_name: prev_v, line.key: line.value}
+            stack.append(
+                _SubConfig(indent=line.indent, content=current.content[prev_k])
+            )
+        else:
+            log.debug("Adding %s=%s.", line.key, line.value)
+            current.content[line.key] = line.value
+
+    return content
+
+
+@dataclass(slots=True, kw_only=True)
+class _SubConfig:
+    indent: int
+    content: dict[str, Any]
+
+
+@dataclass(slots=True, kw_only=True)
+class _Line:
+    indent: int
+    key: str
+    value: str | None
+
+
+_LEADING_WHITESP = re.compile(r"\s*(?=\S)")
+_POS_QUOTED = re.compile(r"'?(?P<cnt>.?)'?")
+_SPEC = re.compile(r"(?P<key>[A-Za-z][\w() -]*?)\s*[:=]\s*(?P<val>.*?)\s*")
+
+
+def _parse_line(
+    line: str,
+    /,
+) -> _Line | None:
+    log.debug("Parsing `%s`.", line)
+    if (lwsp_match := _LEADING_WHITESP.match(line)) is None:
+        # Empty line or line containing only whitespace.
+        log.debug("Skipping empty line.")
+        return None
+
+    lwsp = lwsp_match.group()
+    indent = len(lwsp)
+    content = _POS_QUOTED.sub(r"\g<cnt>", line[lwsp_match.end() :])
+    log.debug("Extracted content: `%s` (indent: %s).", content, indent)
+
+    if (spec_match := _SPEC.fullmatch(content)) is None:
+        raise types.GioParseError("line not matching expected pattern: `%s`", content)
+
+    key, value = spec_match.group("key"), spec_match.group("val") or None
+    log.debug("Found key/value: `%s`=`%s`.", key, value)
+    return _Line(indent=indent, key=key, value=value)

lid/io.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""Functionality for IO."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+from pathlib import Path
+
+import msgspec
+
+from lid import __name__ as pkg_name
+from lid import types
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from typing import Literal, overload
+
+    @overload
+    def _find_binary(binary: str, /) -> str: ...
+    @overload
+    def _find_binary(binary: str, /, accept_failure: Literal[True]) -> str | None: ...
+
+
+__all__ = ["capture_environment"]
+
+
+def _getenv[T](env_var: str, /, default: T) -> T:
+    if (v := os.getenv(env_var)) is None:
+        return default
+    return type(default)(v)
+
+
+def _find_binary(binary: str, /, accept_failure: bool = False) -> str | None:
+    if (abs_path := shutil.which(binary)) is None:
+        if accept_failure:
+            return None
+        raise FileNotFoundError(f"executable '{binary}' not found")
+    return abs_path
+
+
+def capture_environment() -> types.Environment:
+    """Capture environment."""
+    user_id = os.getuid()
+    sys_runtime_dir = Path("/", "run", "user", str(user_id))
+    runtime_dir = _getenv("XDG_RUNTIME_DIR", sys_runtime_dir) / pkg_name
+
+    try:
+        gio_bin = _find_binary(_getenv("LID_GIO", "gio"))
+    except FileNotFoundError as err:
+        raise types.EnvCaptureError("gio binary not found") from err
+
+    try:
+        log_level: int | None = int(os.getenv("LID_LOGLEVEL", ""))
+    except ValueError:
+        log_level = None
+
+    return types.Environment(
+        runtime_dir=runtime_dir, gio_bin=gio_bin, log_level=log_level
+    )
+
+
+# Intentionally returning a list to allow execution in a separate thread.
+def read_mount_markers(env: types.Environment) -> Sequence[tuple[Path, types.Mount]]:
+    decode = msgspec.json.Decoder(type=types.Mount).decode
+
+    markers = []
+    for p in env.runtime_dir.iterdir():
+        if not p.is_file():
+            continue
+
+        with contextlib.suppress(msgspec.DecodeError, msgspec.ValidationError):
+            markers.append((p, decode(p.read_bytes())))
+    return markers

lid/subprocess.py

@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""Functionality for calling subprocesses."""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import os
+
+from lid import types
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+    from typing import Any
+
+__all__ = ["raise_on_stderr", "run"]
+
+RUNNING = contextvars.ContextVar[str]("_RUNNING")
+
+
+def raise_on_stderr(stderr: bytes, /) -> None:
+    if stderr:
+        running = RUNNING.get()
+        err = stderr.decode("utf-8")
+        raise types.SubprocessError(f"{running} generated error message:\n{err}")
+
+
+async def run(
+    bin_: str,
+    *args: str,
+    handle_stderr: Callable[[bytes], None] = raise_on_stderr,
+    env_mods: Mapping[str, str] | None = None,
+) -> str:
+    """Run command and return stdout content."""
+    proc_kwargs: dict[str, Any] = (
+        {"env": os.environ | env_mods} if env_mods is not None else {}
+    )
+    proc = await asyncio.create_subprocess_exec(
+        bin_,
+        *args,
+        stdin=asyncio.subprocess.DEVNULL,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        **proc_kwargs,
+    )
+    token = RUNNING.set(f"`{bin_} {' '.join(args)}`")
+    try:
+        stdout, stderr = await proc.communicate()
+    except asyncio.CancelledError:
+        proc.terminate()
+        RUNNING.reset(token)
+        raise
+
+    if proc.returncode != 0:
+        running = RUNNING.get()
+        RUNNING.reset(token)
+        raise types.SubprocessError(
+            f"{running} exited with return code {proc.returncode}:"
+            f" {stderr.decode('utf-8')}"
+        )
+    try:
+        if stderr:
+            handle_stderr(stderr)
+        stdout = stdout.decode("utf-8")
+    finally:
+        RUNNING.reset(token)
+    return stdout

lid/types.py

@@ -0,0 +1,68 @@
+# SPDX-FileCopyrightText: Christian Heinze
+#
+# SPDX-License-Identifier: MIT
+"""Shared data structures."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import msgspec
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class LidError(RuntimeError):
+    """Exception raised by lid functionality."""
+
+
+class SubprocessError(LidError):
+    """Raised when a subprocess concludes with an error."""
+
+
+class EnvCaptureError(LidError):
+    """Exception raised when capturing the environment fails."""
+
+
+class GioParseError(LidError):
+    """Raised when gio CLI output cannot be parsed."""
+
+
+class GioMountError(LidError):
+    """Exception raised when (un)mounting device fails."""
+
+
+class GioNotFoundError(GioMountError):
+    """Exception raised when (un)mounting device fails due to missing device."""
+
+
+@dataclass(slots=True)
+class Environment:
+    """Captures environment parameters."""
+
+    runtime_dir: Path
+
+    log_level: int | None
+
+    gio_bin: str
+
+
+class Mount(msgspec.Struct, forbid_unknown_fields=True, kw_only=True):
+    """Summary of mount attempt/action.
+
+    Parameters
+    ----------
+    name
+        Device ID as displayed by `gio mount --list`.
+    mountpoint
+        Mountpoint (local directory logically linked to device file system).
+    triggered
+        True if the attempt actually mounted the device.
+    """
+
+    name: str
+    mountpoint: str
+
+    triggered: bool

lid_cli-0.1.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: lid-cli
+Version: 0.1
+Summary: Project Lid Cli.
+Author: Christian Heinze
+License-Expression: MIT
+License-File: LICENSES/MIT.txt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Dist: msgspec>=0.21
+Requires-Dist: rich>=14.3
+Requires-Dist: typer>=0.24
+Requires-Python: >=3.14
+Project-URL: Repository, https://codeberg.org/christianheinze/lid-cli
+Description-Content-Type: text/markdown
+
+# lid-cli
+
+To find device, run `gio mount --list --detail` and select ID in the first line.
+
+## TODO
+
+- More error handling and testing.
+- Build CLI with mount and umount commands.
+- Possibly write target to disk in a small file for umount to read from.

lid_cli-0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+lid/__init__.py,sha256=E7fcaSN9c1x0ewb-WO6q5EPe6eC8DJ45i4kvTaoocHk,658
+lid/__main__.py,sha256=Haato9KRuIG0rhGdZJi2baPNDnFPCbzUddpq-KIndP0,172
+lid/cli.py,sha256=9SVZqEDCilJ2M2ifEf6Ylj6wYCqTu_GbcPTDoFmH7hA,7071
+lid/gio.py,sha256=lge3vnLyErCr_7dGCFcR3G_qEg1t8T_k29saA7UaXDU,9962
+lid/io.py,sha256=q3qaD47lwjNZ0b2mKiG1926ig5-7NQhf7ehuCGgyAT4,2154
+lid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lid/subprocess.py,sha256=28HPv8dhwL6jp5orCjYmp6jKTTSlYD1o0Zny7A7G1ao,1831
+lid/types.py,sha256=dAWbyILef7wqfPe9JguZ9PwjR6tJGO7BfS5gCE6jeTs,1430
+lid_cli-0.1.dist-info/licenses/LICENSES/MIT.txt,sha256=PZVKOoRAo04wioe5oVvpvP925EYXpkOr2y2MMmXy6hY,1072
+lid_cli-0.1.dist-info/WHEEL,sha256=fWriCkzqm-pffF5af4gJC9iI5FMFaJTuN9UxxxzOmdY,81
+lid_cli-0.1.dist-info/entry_points.txt,sha256=8Vj0fd_agODJUYqLNItt9SpHTCyqWmQZ9EALRBpawk0,37
+lid_cli-0.1.dist-info/METADATA,sha256=6Z94Q8zkHye81bDAeNqJmyWoW9DgM_C_bt_jzVAyGGE,969
+lid_cli-0.1.dist-info/RECORD,,

lid_cli-0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.14
+Root-Is-Purelib: true
+Tag: py3-none-any

lid_cli-0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+lid = lid.cli:app
+

lid_cli-0.1.dist-info/licenses/LICENSES/MIT.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright Christian Heinze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.