aiosamstream 0.1.0__tar.gz

aiosamstream-0.1.0/.gitignore

@@ -0,0 +1,58 @@
+__pycache__/
+*.py[cod]
+.venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+dist/
+*.egg-info/
+
+node_modules/
+tv-app/dist/
+tv-app/.buildResult/
+*.wgt
+!custom_components/samstream/bundled/*.wgt
+
+# Local stream URLs / camera credentials
+.env.local
+tv-app/.signing/
+.env.*.local
+
+# Signing material never goes in git
+*.p12
+author.xml
+distributor.xml
+
+# Pairing token written by `python -m aiosamstream pair`
+.samstream-token
+
+# HA URL + long-lived token for dev deploys
+.env.ha
+
+# Local dev secrets (sdb RSA key, etc.)
+.dev/
+
+# Pairing tokens for each TV, and TV state dumps
+.samstream-token*
+tv_state*.json
+
+# OCF research: private keys and TV credentials never go in git
+*.key
+oicseek/tv_cred*.json
+oicseek/tv_state*.json
+
+# Scratch files
+scratchpad/
+
+# OCF / recovery spikes and tooling caches: keys, certs, device ACL dumps, vendored
+# deps and agent runtime state never go in git.
+oicseek/
+dsh-acl-recovery/
+tv-app/probe/
+.claude-flow/
+
+# .NET notifier build output (the prebuilt .tpk is bundled in the integration)
+tv-app/notifier-dotnet/bin/
+tv-app/notifier-dotnet/obj/

aiosamstream-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.5
+Name: aiosamstream
+Version: 0.1.0
+Summary: Async client for Samsung Tizen TVs: control, sdb sideloading and the Samstream player app
+Project-URL: Source, https://github.com/Mrslimon/samstream
+Author: Islam Ahmady
+License-Expression: Apache-2.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.14.2
+Requires-Dist: aiohttp>=3.12
+Requires-Dist: async-timeout>=4
+Requires-Dist: cryptography>=43
+Requires-Dist: samsungtvws[async]<4,>=2.7.2
+Requires-Dist: websockets>=15
+Description-Content-Type: text/markdown
+
+# aiosamstream
+
+Async Python library behind the Samstream Home Assistant integration.
+
+- `tv` – pairing, token persistence, remote keys, device info, app list/launch (wraps `samsungtvws`)
+- `sdb` – pure-Python Smart Development Bridge client (no Tizen Studio binary needed)
+- `signing` – per-TV `.wgt` signing (author + distributor XML signatures)
+- `wol` – directed Wake-on-LAN
+
+Status: skeleton, no logic yet.

aiosamstream-0.1.0/README.md

@@ -0,0 +1,10 @@
+# aiosamstream
+
+Async Python library behind the Samstream Home Assistant integration.
+
+- `tv` – pairing, token persistence, remote keys, device info, app list/launch (wraps `samsungtvws`)
+- `sdb` – pure-Python Smart Development Bridge client (no Tizen Studio binary needed)
+- `signing` – per-TV `.wgt` signing (author + distributor XML signatures)
+- `wol` – directed Wake-on-LAN
+
+Status: skeleton, no logic yet.

aiosamstream-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aiosamstream"
+version = "0.1.0"
+description = "Async client for Samsung Tizen TVs: control, sdb sideloading and the Samstream player app"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.14.2"
+authors = [{ name = "Islam Ahmady" }]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Framework :: AsyncIO",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp>=3.12",
+    "cryptography>=43",  # sdb RSA handshake; already in Home Assistant
+    "samsungtvws[async]>=2.7.2,<4",  # HA core samsungtv pins 2.7.2
+    "websockets>=15",
+    # samsungtvws 2.7.x imports it without declaring it
+    "async-timeout>=4",
+]
+
+[project.urls]
+Source = "https://github.com/Mrslimon/samstream"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aiosamstream"]

aiosamstream-0.1.0/src/aiosamstream/__init__.py

@@ -0,0 +1,47 @@
+"""Async client for Samsung Tizen TVs and the Samstream player app."""
+
+from .apps import KNOWN_APPS, YOUTUBE_APP_ID, ListedApp, parse_app_list
+from .art import ArtConnection
+from .cast import youtube_id
+from .const import SAMSTREAM_APP_ID
+from .exceptions import (
+    OcfError,
+    OcfNotConnectedError,
+    OcfTvOwnedError,
+    SamstreamAuthError,
+    SamstreamConnectionError,
+    SamstreamError,
+    SamstreamTimeoutError,
+    SdbConnectionError,
+    SdbError,
+)
+from .models import AppStatus, DeviceInfo
+from .sdb import InstallResult, SdbClient, generate_key
+from .tv import SamsungTV
+from .wol import send_magic_packet
+
+__all__ = [
+    "KNOWN_APPS",
+    "SAMSTREAM_APP_ID",
+    "YOUTUBE_APP_ID",
+    "AppStatus",
+    "ArtConnection",
+    "DeviceInfo",
+    "InstallResult",
+    "ListedApp",
+    "OcfError",
+    "OcfNotConnectedError",
+    "OcfTvOwnedError",
+    "SamstreamAuthError",
+    "SamstreamConnectionError",
+    "SamstreamError",
+    "SamstreamTimeoutError",
+    "SamsungTV",
+    "SdbClient",
+    "SdbConnectionError",
+    "SdbError",
+    "generate_key",
+    "parse_app_list",
+    "send_magic_packet",
+    "youtube_id",
+]

aiosamstream-0.1.0/src/aiosamstream/__main__.py

@@ -0,0 +1,104 @@
+"""Developer CLI: `python -m aiosamstream {info,pair,wol} --host <tv>`."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import dataclasses
+import json
+from pathlib import Path
+
+import aiohttp
+
+from . import SamstreamError, SamsungTV, send_magic_packet
+from .wol import DEFAULT_TARGET
+
+
+async def _run(args: argparse.Namespace, token: str | None) -> int:
+    token_file = Path(args.token_file)
+    async with aiohttp.ClientSession() as session:
+        tv = SamsungTV(args.host, session, token=token)
+        if args.command == "info":
+            info = await tv.device_info()
+            print(json.dumps(dataclasses.asdict(info), indent=2, ensure_ascii=False))
+        elif args.command == "pair":
+            if token:
+                print("Stored token found: the TV should accept without a popup.")
+            else:
+                print('Accept the "Allow" popup on the TV...')
+            new_token = await tv.pair(accept_within=args.wait)
+            if new_token is None:
+                print("This TV does not use token authentication.")
+            elif new_token == token:
+                print("Connected with the stored token (no popup).")
+            else:
+                await asyncio.to_thread(token_file.write_text, new_token, "utf-8")
+                print(f"Paired, token saved to {token_file}.")
+        elif args.command == "wol":
+            mac = args.mac or (await tv.device_info()).mac
+            if not mac:
+                print("No MAC known, pass --mac.")
+                return 1
+            await send_magic_packet(mac, target=args.target)
+            print(f"Magic packet sent to {mac} via {args.target}.")
+        elif args.command == "art":
+            return await _run_art(tv, args)
+    return 0
+
+
+async def _run_art(tv: SamsungTV, args: argparse.Namespace) -> int:
+    """Run one `art` subcommand (probing a Frame's art-app channel)."""
+    async with tv.art() as art:
+        if args.art == "status":
+            print(f"art mode: {'on' if await art.get_art_mode() else 'off'}")
+        elif args.art == "list":
+            items = await art.available()
+            print(f"{len(items)} artworks:")
+            for item in items:
+                print(f"  {item.get('content_id')}  {item.get('category_id')}")
+        elif args.art == "current":
+            print(f"current: {await art.current()}")
+        elif args.art in ("on", "off"):
+            await art.set_art_mode(on=args.art == "on")
+            print(f"art mode -> {args.art}")
+        elif args.art == "select":
+            if not args.content_id:
+                print("Pass --content-id.")
+                return 1
+            await art.select(args.content_id)
+            print(f"selected {args.content_id}")
+    return 0
+
+
+def main() -> int:
+    """Parse arguments and run one command."""
+    parser = argparse.ArgumentParser(prog="python -m aiosamstream")
+    parser.add_argument("command", choices=["info", "pair", "wol", "art"])
+    parser.add_argument("--host", required=True)
+    parser.add_argument(
+        "--art",
+        choices=["status", "list", "current", "on", "off", "select"],
+        default="status",
+        help="art subcommand (with `art`)",
+    )
+    parser.add_argument("--content-id", help="artwork id for `art --art select`")
+    parser.add_argument("--token-file", default=".samstream-token")
+    parser.add_argument("--wait", type=float, default=60, help="seconds to accept")
+    parser.add_argument("--mac", help="for wol; read from the TV when omitted")
+    parser.add_argument(
+        "--target", default=DEFAULT_TARGET, help="wol broadcast/unicast address"
+    )
+    args = parser.parse_args()
+    token_file = Path(args.token_file)
+    token = None
+    if token_file.exists():
+        token = token_file.read_text(encoding="utf-8").strip()
+    try:
+        return asyncio.run(_run(args, token))
+    except SamstreamError as err:
+        print(f"Error: {err}")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aiosamstream-0.1.0/src/aiosamstream/apps.py

@@ -0,0 +1,83 @@
+"""Known Tizen app IDs.
+
+2020+ firmwares no longer answer `ed.installedApp.get`, so the installed apps are
+found by asking the TV about each known ID (unknown ones answer 404). Names here
+are only fallbacks: the TV reports its own.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Final
+
+from .const import SAMSTREAM_APP_ID
+
+# The YouTube Tizen app; launched with a `v=<id>` deep link to cast a video.
+YOUTUBE_APP_ID: Final = "111299001912"
+
+# Confirmed on a 2023 QN800C (Tizen 9): YouTube, Netflix, Prime Video, Spotify,
+# Apple TV, Browser. The others are widely published IDs.
+KNOWN_APPS: Final[dict[str, str]] = {
+    YOUTUBE_APP_ID: "YouTube",
+    "3201907018807": "Netflix",
+    "3201910019365": "Prime Video",
+    "3201901017640": "Disney+",
+    "3201606009684": "Spotify",
+    "3201807016597": "Apple TV",
+    "3201908019041": "Apple Music",
+    "3202010022079": "Browser",
+    "3201512006963": "Plex",
+    "3201611010983": "YouTube Kids",
+    "3201601007230": "HBO Max",
+    "3201710014981": "Paramount+",
+    "3201808016802": "Pluto TV",
+    "3201511006428": "Rakuten TV",
+    "3201608010385": "Deezer",
+    "3201702011851": "Steam Link",
+    "11091000000": "Facebook Watch",
+    SAMSTREAM_APP_ID: "Samstream",
+}
+
+
+# vd_applist prints blocks of "-------<key>   =<value>-------" lines between rules.
+_FIELD = re.compile(r"^\s*-{3,}\s*(?P<key>[^\s=]+)\s*=\s*(?P<value>.*?)\s*-{3,}\s*$")
+
+
+@dataclass(frozen=True, slots=True)
+class ListedApp:
+    """One installed app from `vd_applist` (needs Developer Mode / sdb)."""
+
+    # The store ID the REST API understands (e.g. 111299001912), not the Tizen ID.
+    app_id: str
+    tizen_id: str
+    name: str
+    version: str | None
+
+
+def parse_app_list(text: str) -> list[ListedApp]:
+    """Parse `0 vd_applist` output; hidden apps are left out."""
+    blocks: list[dict[str, str]] = []
+    current: dict[str, str] = {}
+    for line in text.splitlines():
+        if match := _FIELD.match(line):
+            current[match.group("key")] = match.group("value")
+        elif current and "----" in line and "=" not in line:
+            blocks.append(current)
+            current = {}
+    if current:
+        blocks.append(current)
+    listed = []
+    for block in blocks:
+        app_id = block.get("app_id") or block.get("app_tizen_id")
+        if not app_id or block.get("is_hidden") == "1":
+            continue
+        listed.append(
+            ListedApp(
+                app_id=app_id,
+                tizen_id=block.get("app_tizen_id", app_id),
+                name=block.get("app_title") or app_id,
+                version=block.get("app_version") or None,
+            )
+        )
+    return listed