pyatv-http 0.1.0__py3-none-any.whl

pyatv_http/app.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import asyncio
+
+from fastapi import Depends, FastAPI, HTTPException
+from pyatv.const import PowerState
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from pyatv_http import atv
+from pyatv_http.atv import DeviceUnreachableError
+from pyatv_http.auth import require_token
+from pyatv_http.config import AppConfig
+
+
+async def _health(_request: Request) -> JSONResponse:
+    return JSONResponse({"status": "ok"})
+
+
+def create_app(config: AppConfig) -> FastAPI:
+    app = FastAPI(dependencies=[Depends(require_token(config))])
+
+    # Added as a raw Starlette route (like FastAPI's own /docs, /openapi.json)
+    # so it bypasses the app-wide bearer-token dependency above -- health
+    # probes (load balancers, uptime checks) shouldn't need a token.
+    app.add_route("/health", _health, methods=["GET"])
+
+    def _get_device(name: str):
+        device = config.get_device(name)
+        if device is None:
+            raise HTTPException(status_code=404, detail=f"unknown device: {name}")
+        return device
+
+    async def _set_power_state(name: str, desired: PowerState) -> dict[str, str]:
+        device = _get_device(name)
+        loop = asyncio.get_running_loop()
+        try:
+            state = await atv.set_power_state(loop, device, desired)
+        except DeviceUnreachableError as exc:
+            raise HTTPException(status_code=504, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+        return {"device": name, "power_state": state.name.lower()}
+
+    @app.post("/{name}/turnOn")
+    async def turn_on(name: str) -> dict[str, str]:
+        return await _set_power_state(name, PowerState.On)
+
+    @app.post("/{name}/turnOff")
+    async def turn_off(name: str) -> dict[str, str]:
+        return await _set_power_state(name, PowerState.Off)
+
+    @app.get("/{name}/powerState")
+    async def power_state(name: str) -> dict[str, str]:
+        device = _get_device(name)
+        loop = asyncio.get_running_loop()
+        try:
+            state = await atv.get_power_state(loop, device)
+        except DeviceUnreachableError as exc:
+            raise HTTPException(status_code=504, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+        return {"device": name, "power_state": state.name.lower()}
+
+    @app.get("/devices")
+    async def list_devices() -> list[dict[str, str]]:
+        return [
+            {"device": device.key, "name": device.name}
+            for device in sorted(config.devices.values(), key=lambda d: d.key)
+        ]
+
+    return app

pyatv_http/atv.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import asyncio
+
+import pyatv
+from pyatv.const import PowerState
+from pyatv.interface import AppleTV
+from pyatv.settings import (
+    AirPlaySettings,
+    CompanionSettings,
+    DmapSettings,
+    MrpSettings,
+    ProtocolSettings,
+    RaopSettings,
+    Settings,
+)
+from pyatv.storage import MODEL_VERSION, StorageModel
+from pyatv.storage.memory_storage import MemoryStorage
+
+from pyatv_http.config import DeviceConfig, ProtocolCredential
+
+SCAN_TIMEOUT_SECONDS = 5
+
+
+class DeviceUnreachableError(Exception):
+    """Raised when the Apple TV cannot be found on the network."""
+
+
+def _protocol_settings(
+    device: DeviceConfig,
+) -> dict[
+    str, AirPlaySettings | CompanionSettings | DmapSettings | MrpSettings | RaopSettings
+]:
+    empty = ProtocolCredential()
+    airplay = device.protocols.get("airplay", empty)
+    companion = device.protocols.get("companion", empty)
+    dmap = device.protocols.get("dmap", empty)
+    mrp = device.protocols.get("mrp", empty)
+    raop = device.protocols.get("raop", empty)
+
+    return {
+        "airplay": AirPlaySettings(
+            identifier=airplay.identifier,
+            credentials=airplay.credentials,
+            password=airplay.password,
+        ),
+        "companion": CompanionSettings(
+            identifier=companion.identifier, credentials=companion.credentials
+        ),
+        "dmap": DmapSettings(identifier=dmap.identifier, credentials=dmap.credentials),
+        "mrp": MrpSettings(identifier=mrp.identifier, credentials=mrp.credentials),
+        "raop": RaopSettings(
+            identifier=raop.identifier,
+            credentials=raop.credentials,
+            password=raop.password,
+        ),
+    }
+
+
+def _build_storage(device: DeviceConfig) -> MemoryStorage:
+    settings = Settings(protocols=ProtocolSettings(**_protocol_settings(device)))
+    storage = MemoryStorage()
+    storage.storage_model = StorageModel(version=MODEL_VERSION, devices=[settings])
+    return storage
+
+
+async def connect(loop: asyncio.AbstractEventLoop, device: DeviceConfig) -> AppleTV:
+    results = await pyatv.scan(
+        loop,
+        hosts=[device.address],
+        identifier={device.identifier},
+        timeout=SCAN_TIMEOUT_SECONDS,
+    )
+    if not results:
+        raise DeviceUnreachableError(
+            f"could not find '{device.name}' ({device.identifier}) at {device.address}"
+        )
+
+    storage = _build_storage(device)
+    return await pyatv.connect(results[0], loop, storage=storage)
+
+
+async def get_power_state(
+    loop: asyncio.AbstractEventLoop, device: DeviceConfig
+) -> PowerState:
+    atv = await connect(loop, device)
+    try:
+        return atv.power.power_state
+    finally:
+        atv.close()
+
+
+async def set_power_state(
+    loop: asyncio.AbstractEventLoop, device: DeviceConfig, desired: PowerState
+) -> PowerState:
+    atv = await connect(loop, device)
+    try:
+        current = atv.power.power_state
+        if current == desired:
+            return current
+
+        # await_new_state=True raises NotImplementedError on pyatv's Companion
+        # protocol (pyatv/protocols/companion/__init__.py); we already read the
+        # state ourselves above, so we don't need pyatv to wait for it too.
+        if desired == PowerState.On:
+            await atv.power.turn_on(await_new_state=False)
+        else:
+            await atv.power.turn_off(await_new_state=False)
+        return desired
+    finally:
+        atv.close()

pyatv_http/auth.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from pyatv_http.config import AppConfig
+
+_bearer_scheme = HTTPBearer(auto_error=False)
+
+
+def require_token(config: AppConfig):
+    def _verify(
+        credentials: Annotated[
+            HTTPAuthorizationCredentials | None, Depends(_bearer_scheme)
+        ] = None,
+    ) -> None:
+        if credentials is None or credentials.credentials not in config.auth_tokens:
+            raise HTTPException(
+                status_code=401,
+                detail="missing or invalid bearer token",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+    return _verify

pyatv_http/cli.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+import uvicorn
+
+from pyatv_http.app import create_app
+from pyatv_http.config import load_config
+from pyatv_http.gen_config import DeviceNotFoundError, generate_config_block
+
+DEFAULT_STORAGE_PATH = Path.home() / ".pyatv.conf"
+
+
+def default_config_path() -> Path:
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    config_home = Path(xdg_config_home) if xdg_config_home else Path.home() / ".config"
+    return config_home / "pyatv-http" / "config.toml"
+
+
+def _serve(args: argparse.Namespace) -> None:
+    config_path = args.config or default_config_path()
+    config = load_config(config_path)
+    app = create_app(config)
+    uvicorn.run(app, host=args.host, port=config.port)
+
+
+def _gen_config(args: argparse.Namespace) -> None:
+    storage_path = args.storage or DEFAULT_STORAGE_PATH
+    try:
+        block = asyncio.run(
+            generate_config_block(
+                storage_path=storage_path,
+                identifier=args.identifier,
+                key=args.key,
+                name=args.name,
+                address=args.address,
+            )
+        )
+    except DeviceNotFoundError as exc:
+        print(str(exc), file=sys.stderr)
+        raise SystemExit(1) from exc
+
+    print(block)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="pyatv-http")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    serve = subparsers.add_parser("serve", help="Run the HTTP server")
+    serve.add_argument(
+        "--config",
+        default=None,
+        help=f"Path to the config TOML file (default: {default_config_path()})",
+    )
+    serve.add_argument("--host", default="0.0.0.0", help="Interface to bind to")
+    serve.set_defaults(func=_serve)
+
+    gen_config = subparsers.add_parser(
+        "gen-config",
+        help="Generate a [devices.<key>] config block from an atvremote pairing",
+    )
+    gen_config.add_argument(
+        "--storage",
+        default=None,
+        help=f"Path to atvremote's storage file (default: {DEFAULT_STORAGE_PATH})",
+    )
+    gen_config.add_argument(
+        "--identifier", required=True, help="Device identifier to look up"
+    )
+    gen_config.add_argument(
+        "--key", required=True, help="Config key / URL path segment for this device"
+    )
+    gen_config.add_argument("--name", default=None, help="Display name (default: key)")
+    gen_config.add_argument(
+        "--address", required=True, help="IP address or hostname of the Apple TV"
+    )
+    gen_config.set_defaults(func=_gen_config)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

pyatv_http/config.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+KNOWN_PROTOCOLS = frozenset({"airplay", "companion", "dmap", "mrp", "raop"})
+
+
+class ConfigError(Exception):
+    """Raised when the config file is missing or invalid."""
+
+
+@dataclass(frozen=True)
+class ProtocolCredential:
+    identifier: str | None = None
+    credentials: str | None = None
+    password: str | None = None
+
+
+@dataclass(frozen=True)
+class DeviceConfig:
+    key: str
+    name: str
+    address: str
+    identifier: str
+    protocols: dict[str, ProtocolCredential] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    port: int
+    devices: dict[str, DeviceConfig]
+    auth_tokens: frozenset[str]
+
+    def get_device(self, key: str) -> DeviceConfig | None:
+        return self.devices.get(key)
+
+
+def _parse_protocol(device_key: str, proto_name: str, raw: dict) -> ProtocolCredential:
+    if proto_name not in KNOWN_PROTOCOLS:
+        raise ConfigError(
+            f"devices.{device_key}.protocols.{proto_name}: unknown protocol "
+            f"(expected one of {sorted(KNOWN_PROTOCOLS)})"
+        )
+    return ProtocolCredential(
+        identifier=raw.get("identifier"),
+        credentials=raw.get("credentials"),
+        password=raw.get("password"),
+    )
+
+
+def _parse_device(key: str, raw: dict) -> DeviceConfig:
+    name = raw.get("name")
+    if not name:
+        raise ConfigError(f"devices.{key}: missing required field 'name'")
+
+    identifier = raw.get("identifier")
+    if not identifier:
+        raise ConfigError(f"devices.{key}: missing required field 'identifier'")
+
+    address = raw.get("address")
+    if not address:
+        raise ConfigError(f"devices.{key}: missing required field 'address'")
+
+    raw_protocols = raw.get("protocols", {})
+    protocols = {
+        proto_name: _parse_protocol(key, proto_name, proto_raw)
+        for proto_name, proto_raw in raw_protocols.items()
+    }
+
+    return DeviceConfig(
+        key=key,
+        name=name,
+        address=address,
+        identifier=identifier,
+        protocols=protocols,
+    )
+
+
+def _parse_auth_tokens(data: dict) -> frozenset[str]:
+    raw_auth = data.get("auth")
+    if not raw_auth:
+        raise ConfigError("missing or empty required table 'auth'")
+
+    tokens = raw_auth.get("tokens")
+    if not tokens:
+        raise ConfigError("missing or empty required field 'auth.tokens'")
+
+    return frozenset(tokens)
+
+
+def load_config(path: str | Path) -> AppConfig:
+    path = Path(path)
+    if not path.is_file():
+        raise ConfigError(f"config file not found: {path}")
+
+    data = tomllib.loads(path.read_text())
+
+    port = data.get("port")
+    if not isinstance(port, int):
+        raise ConfigError("missing or invalid required field 'port'")
+
+    raw_devices = data.get("devices")
+    if not raw_devices:
+        raise ConfigError("missing or empty required table 'devices'")
+
+    devices = {
+        key: _parse_device(key, raw_device) for key, raw_device in raw_devices.items()
+    }
+
+    auth_tokens = _parse_auth_tokens(data)
+
+    return AppConfig(port=port, devices=devices, auth_tokens=auth_tokens)

pyatv_http/gen_config.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from pyatv.settings import Settings
+from pyatv.storage.file_storage import FileStorage
+
+PROTOCOL_NAMES = ("airplay", "companion", "dmap", "mrp", "raop")
+
+
+class DeviceNotFoundError(Exception):
+    """Raised when no stored device matches the given identifier."""
+
+
+def _escape_toml_string(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def _toml_string(value: str) -> str:
+    return f'"{_escape_toml_string(value)}"'
+
+
+def _settings_identifiers(settings: Settings) -> set[str]:
+    identifiers = set()
+    for proto_name in PROTOCOL_NAMES:
+        proto_identifier = getattr(settings.protocols, proto_name).identifier
+        if proto_identifier is not None:
+            identifiers.add(proto_identifier)
+    return identifiers
+
+
+def _find_settings(devices: list[Settings], identifier: str) -> Settings | None:
+    for settings in devices:
+        if identifier in _settings_identifiers(settings):
+            return settings
+    return None
+
+
+def render_toml_block(
+    *,
+    key: str,
+    name: str,
+    address: str,
+    identifier: str,
+    protocols: dict[str, dict[str, str | None]],
+) -> str:
+    lines = [
+        f"[devices.{key}]",
+        f"name = {_toml_string(name)}",
+        f"identifier = {_toml_string(identifier)}",
+        f"address = {_toml_string(address)}",
+    ]
+
+    for proto_name in PROTOCOL_NAMES:
+        proto = protocols.get(proto_name)
+        if not proto:
+            continue
+        if not proto.get("identifier") and not proto.get("credentials"):
+            continue
+
+        lines.append("")
+        lines.append(f"[devices.{key}.protocols.{proto_name}]")
+        for field_name in ("identifier", "credentials", "password"):
+            value = proto.get(field_name)
+            if value is not None:
+                lines.append(f"{field_name} = {_toml_string(value)}")
+
+    return "\n".join(lines) + "\n"
+
+
+async def generate_config_block(
+    *,
+    storage_path: str | Path,
+    identifier: str,
+    key: str,
+    name: str | None,
+    address: str,
+) -> str:
+    loop = asyncio.get_running_loop()
+    storage = FileStorage(str(storage_path), loop)
+    await storage.load()
+
+    devices = list(storage.settings)
+    settings = _find_settings(devices, identifier)
+    if settings is None:
+        available = sorted(
+            {i for device in devices for i in _settings_identifiers(device)}
+        )
+        raise DeviceNotFoundError(
+            f"no paired device found with identifier '{identifier}'. "
+            f"Available identifiers: {available}"
+        )
+
+    protocols = {
+        proto_name: dict(getattr(settings.protocols, proto_name))
+        for proto_name in PROTOCOL_NAMES
+    }
+
+    return render_toml_block(
+        key=key,
+        name=name or key,
+        address=address,
+        identifier=identifier,
+        protocols=protocols,
+    )

pyatv_http-0.1.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: pyatv-http
+Version: 0.1.0
+Summary: HTTP interface for controlling Apple TVs via pyatv
+Project-URL: Homepage, https://github.com/hugoh/pyatv-http
+Project-URL: Repository, https://github.com/hugoh/pyatv-http
+Project-URL: Issues, https://github.com/hugoh/pyatv-http/issues
+Author: Hugo Haas
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.121.0
+Requires-Dist: pyatv>=0.16.0
+Requires-Dist: uvicorn>=0.38.0
+Description-Content-Type: text/markdown
+
+# pyatv-http
+
+An HTTP interface for controlling Apple TVs, built on top of
+[pyatv](https://github.com/postlund/pyatv).
+
+## Features
+
+- `POST /<name>/turnOn` and `POST /<name>/turnOff` — checks the Apple TV's current
+  power state and only sends a command if it differs from the desired state.
+- `GET /<name>/powerState` — reads the current power state without changing it.
+- `GET /devices` — lists the devices available in the config file.
+- `GET /health` — unauthenticated liveness check, for load balancers/uptime
+  monitors.
+- Every other request requires a bearer token, configured as a list of
+  accepted tokens in the config file.
+- Config-driven: one TOML file lists the port to listen on, accepted API
+  tokens, and the paired devices.
+- Pairing stays out-of-band, via pyatv's own `atvremote` CLI; a `pyatv-http gen-config`
+  helper turns a paired device's stored credentials into a config snippet.
+
+## Setup
+
+### 1. Find your Apple TV
+
+```sh
+uvx --from pyatv atvremote scan
+```
+
+This lists every Apple TV on the network along with its identifiers, IP
+address, and which protocols it supports (AirPlay, Companion, etc).
+
+### 2. Pair with `atvremote`
+
+Power control uses the **Companion** protocol, and pyatv-http talks to the
+device over **AirPlay** for the initial handshake, so pair both:
+
+```sh
+uvx --from pyatv atvremote --id <device-identifier> pair --protocol airplay
+uvx --from pyatv atvremote --id <device-identifier> pair --protocol companion
+```
+
+Follow the on-screen PIN prompt for each. Credentials are stored in pyatv's
+storage file (default `~/.pyatv.conf`).
+
+### 3. Generate a config entry
+
+```sh
+uv run pyatv-http gen-config \
+  --identifier <device-identifier> \
+  --address <device-ip-or-hostname> \
+  --key living_room
+```
+
+`<device-identifier>` and `<device-ip-or-hostname>` come from the `scan`
+output in step 1; `--key` is whatever short name you want to use in URLs
+(`--name` sets the human-readable display name too, defaulting to `--key`).
+
+This prints a `[devices.living_room]` TOML block built from the stored
+pairing. Paste it into your config file (see below). If the identifier
+doesn't match any paired device, the command lists the identifiers it does
+have on file.
+
+### 4. Write the config file
+
+```toml
+port = 8080
+
+[auth]
+tokens = ["a-long-random-token"]
+
+[devices.living_room]
+name = "Living Room"
+identifier = "AA:BB:CC:DD:EE:FF"
+address = "10.0.0.5"
+
+[devices.living_room.protocols.airplay]
+identifier = "AA:BB:CC:DD:EE:FF"
+credentials = "..."
+
+[devices.living_room.protocols.companion]
+identifier = "11:22:33:44:55:66"
+credentials = "..."
+```
+
+- `port` — port the HTTP server listens on.
+- `[auth].tokens` — required, non-empty list of bearer tokens accepted on every
+  request (see [API](#api) below). Generate one with e.g.
+  `python3 -c "import secrets; print(secrets.token_urlsafe(32))"`.
+- The `[devices.<key>]` table key (`living_room` above) is the URL path
+  segment used in requests, e.g. `POST /living_room/turnOn`.
+- `identifier` — the device's main pyatv identifier (from `atvremote scan`).
+- `address` — the Apple TV's IP address or hostname; used to connect
+  directly instead of relying on mDNS discovery at request time.
+- `[devices.<key>.protocols.<protocol>]` — one block per paired protocol,
+  exactly as generated by `gen-config`. Supported protocol names: `airplay`,
+  `companion`, `dmap`, `mrp`, `raop`.
+
+### 5. Run the server
+
+```sh
+uv run pyatv-http serve --config config.toml
+```
+
+`--config` is optional; if omitted, it defaults to
+`$XDG_CONFIG_HOME/pyatv-http/config.toml`, falling back to
+`~/.config/pyatv-http/config.toml` when `$XDG_CONFIG_HOME` isn't set.
+
+By default the server binds `0.0.0.0`; pass `--host` to bind a specific
+interface.
+
+## API
+
+Every request must include one of the configured tokens as a bearer token:
+
+```sh
+TOKEN=a-long-random-token
+
+curl -X POST http://localhost:8080/living_room/turnOn \
+  -H "Authorization: Bearer $TOKEN"
+
+curl -X POST http://localhost:8080/living_room/turnOff \
+  -H "Authorization: Bearer $TOKEN"
+
+curl http://localhost:8080/living_room/powerState \
+  -H "Authorization: Bearer $TOKEN"
+
+curl http://localhost:8080/devices \
+  -H "Authorization: Bearer $TOKEN"
+
+curl http://localhost:8080/health
+```
+
+`turnOn`/`turnOff`/`powerState` return a JSON body:
+`{"device": "living_room", "power_state": "on"}`.
+
+`GET /devices` returns the devices available in the config file:
+
+```json
+[{"device": "living_room", "name": "Living Room"}]
+```
+
+`GET /health` (no token required) returns `{"status": "ok"}`.
+
+| Status | Meaning                                                           |
+| ------ | ------------------------------------------------------------------ |
+| 200    | Command sent (or no-op, if the device was already in that state)   |
+| 401    | Missing or invalid bearer token                                    |
+| 404    | No device configured under that name                               |
+| 504    | Device could not be found/reached on the network                   |
+| 502    | pyatv raised an error while connecting or sending the command      |
+
+### Interactive API docs
+
+FastAPI auto-generates interactive documentation for the running server:
+
+- `GET /docs` — Swagger UI (use the "Authorize" button to set your bearer
+  token, then try requests directly from the browser).
+- `GET /redoc` — ReDoc view of the same schema.
+- `GET /openapi.json` — the raw OpenAPI schema.
+
+These three routes are not themselves behind the bearer-token check.
+
+## Notes
+
+- Each request opens a fresh connection to the Apple TV, checks its current
+  power state, and only sends `turnOn`/`turnOff` if it differs from the
+  desired state — there's no persistent connection or background polling.
+- Pairing is entirely out-of-band via `atvremote`; this project never
+  performs the pairing handshake itself.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+hk check --all
+```

pyatv_http-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyatv_http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyatv_http/app.py,sha256=-NMn_GPo1dEfU12fM50GO4zFTzUpKnO_lf33jJBBKaM,2705
+pyatv_http/atv.py,sha256=bhMOyup1UJtHm5XIoexewKLvTNs6HoROBqrOY5i2Gf0,3439
+pyatv_http/auth.py,sha256=sF3js3joyfO4ydUqrXwm0gLJLjcgVmuqf1llWVPA9po,761
+pyatv_http/cli.py,sha256=WuzL0VOOt75Aufs7FLj0MaO2LrGxbOlXFOtVjR-wJxY,2831
+pyatv_http/config.py,sha256=ViINn8vO3DTB5dGi6J0AfjMEUTNhDMakxlUw4SfJbnk,3152
+pyatv_http/gen_config.py,sha256=A66dFuMASPa8luMMrZTx44fr4FDtaL4bX_gsIGy1Hn0,2920
+pyatv_http-0.1.0.dist-info/METADATA,sha256=pcz_BWIdRjSsWm5KjqKEN--O3sUvJ1fjCa3vlwojs0g,6786
+pyatv_http-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+pyatv_http-0.1.0.dist-info/entry_points.txt,sha256=qd70JeIvePekCQdNLKwdJTS7rASr5O7qDiGFIw9xJD0,51
+pyatv_http-0.1.0.dist-info/licenses/LICENSE,sha256=qCv-aayDkFcB09IGjnNETtrZ31NOA1tdCq4IJ7nZObc,1066
+pyatv_http-0.1.0.dist-info/RECORD,,

pyatv_http-0.1.0.dist-info/WHEEL

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

pyatv_http-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyatv-http = pyatv_http.cli:main

pyatv_http-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hugo Haas
+
+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.