lanstreamer-sdk 1.0.0__py3-none-any.whl

lanstreamer_sdk/__init__.py

@@ -0,0 +1,73 @@
+"""lan-streamer plugin SDK – the only package an input plugin depends on.
+
+A plugin is a folder (or .zip) with a ``plugin.toml`` and a Python module:
+
+    # plugin.toml
+    id = "my-input"
+    name = "My input"
+    version = "1.0.0"
+    api_version = 1
+    entry = "my_input:Plugin"
+
+    # my_input.py
+    from lanstreamer_sdk import InputPlugin, UriSource
+    from pydantic import BaseModel
+
+    class Settings(BaseModel):
+        url: str
+
+    class Plugin(InputPlugin[Settings]):
+        Settings = Settings
+
+        async def is_active(self) -> bool:
+            return True
+
+        async def get_source(self):
+            return UriSource(self.settings.url)
+
+Every plugin instance runs in its own process (see docs/architecture.md).
+"""
+
+from lanstreamer_sdk.manifest import Manifest, ManifestError, load_manifest
+from lanstreamer_sdk.plugin import (
+    API_VERSION,
+    CardSource,
+    FileSource,
+    ImageSource,
+    InputPlugin,
+    MediaSource,
+    Metadata,
+    NoSettings,
+    PlaybackEvent,
+    PluginContext,
+    Rejected,
+    Store,
+    TestSource,
+    UriSource,
+    Viewer,
+    ViewerItem,
+    source_to_dict,
+)
+
+__all__ = [
+    "API_VERSION",
+    "CardSource",
+    "FileSource",
+    "ImageSource",
+    "InputPlugin",
+    "Manifest",
+    "ManifestError",
+    "MediaSource",
+    "Metadata",
+    "NoSettings",
+    "PlaybackEvent",
+    "PluginContext",
+    "Rejected",
+    "Store",
+    "TestSource",
+    "UriSource",
+    "Viewer",
+    "ViewerItem",
+    "load_manifest",
+    "source_to_dict",
+]

lanstreamer_sdk/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from lanstreamer_sdk.tools import main
+
+sys.exit(main())

lanstreamer_sdk/manifest.py

@@ -0,0 +1,76 @@
+"""plugin.toml: what a plugin is and whether this lan-streamer can run it (F-PLG-04)."""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from lanstreamer_sdk.plugin import API_VERSION
+
+ID_PATTERN = re.compile(r"^[a-z0-9][a-z0-9-]{1,48}$")
+_ENTRY = re.compile(r"^[A-Za-z_][\w.]*:[A-Za-z_]\w*$")
+# the plugins inside lan-streamer; an upload with one of these ids is refused
+BUILTIN_IDS = frozenset({"ingest", "playlist", "standby", "submissions", "test-pattern", "youtube"})
+
+
+class ManifestError(ValueError):
+    pass
+
+
+def check_id_is_free(plugin_id: str) -> None:
+    if plugin_id in BUILTIN_IDS:
+        raise ManifestError(f"plugin id '{plugin_id}' belongs to a built-in plugin, choose another")
+
+
+@dataclass(frozen=True)
+class Manifest:
+    id: str
+    name: str
+    version: str
+    api_version: int
+    entry: str  # "module:Class"
+    description: str = ""
+    requirements: list[str] = field(default_factory=list)
+    path: Path | None = None  # folder that holds plugin.toml
+
+
+def load_manifest(folder: Path) -> Manifest:
+    """Reads and checks folder/plugin.toml. Raises ManifestError with a clear message."""
+    file = folder / "plugin.toml"
+    if not file.is_file():
+        raise ManifestError("plugin.toml is missing")
+    try:
+        data = tomllib.loads(file.read_text(encoding="utf-8"))
+    except tomllib.TOMLDecodeError as exc:
+        raise ManifestError(f"plugin.toml is not valid TOML: {exc}") from exc
+
+    for key in ("id", "name", "version", "api_version", "entry"):
+        if key not in data:
+            raise ManifestError(f"plugin.toml: '{key}' is missing")
+    if not ID_PATTERN.match(str(data["id"])):
+        raise ManifestError("plugin.toml: 'id' must be 2–49 characters: a-z, 0-9 and '-'")
+    if not _ENTRY.match(str(data["entry"])):
+        raise ManifestError("plugin.toml: 'entry' must look like 'module:ClassName'")
+    if not isinstance(data["api_version"], int):
+        raise ManifestError("plugin.toml: 'api_version' must be a whole number")
+    if data["api_version"] != API_VERSION:
+        raise ManifestError(
+            f"plugin needs plugin API {data['api_version']}, "
+            f"this lan-streamer provides API {API_VERSION}"
+        )
+    requirements = data.get("requirements", [])
+    if not isinstance(requirements, list) or not all(isinstance(r, str) for r in requirements):
+        raise ManifestError("plugin.toml: 'requirements' must be a list of strings")
+
+    return Manifest(
+        id=data["id"],
+        name=str(data["name"]),
+        version=str(data["version"]),
+        api_version=data["api_version"],
+        entry=data["entry"],
+        description=str(data.get("description", "")),
+        requirements=requirements,
+        path=folder,
+    )

lanstreamer_sdk/plugin.py

@@ -0,0 +1,260 @@
+"""The input plugin API, version 1."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from collections.abc import AsyncIterator, Callable
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, ClassVar, Literal
+
+from pydantic import BaseModel
+
+API_VERSION = 1
+
+
+# --- What a plugin can play ---------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class TestSource:
+    """A generated test picture with a tone."""
+
+    __test__ = False  # not a pytest test class
+
+    pattern: str = "smpte"  # any GStreamer videotestsrc pattern
+    freq: int = 440
+    kind: Literal["test"] = "test"
+
+
+@dataclass(frozen=True)
+class UriSource:
+    """Anything GStreamer can open by URI: http(s) HLS/MP4, rtsp, srt, file.
+
+    audio_uri: the sound from a second URI, when picture and sound come
+    separately (YouTube in HD); uri then gives only the picture.
+    """
+
+    uri: str
+    audio_uri: str = ""
+    kind: Literal["uri"] = "uri"
+
+
+@dataclass(frozen=True)
+class FileSource:
+    """A local media file.
+
+    cut: switch to it without crossfade, so nothing of its start is lost
+    (e.g. a video that follows an announcement card).
+    """
+
+    path: str
+    cut: bool = False
+    kind: Literal["file"] = "file"
+
+
+@dataclass(frozen=True)
+class ImageSource:
+    """A still picture (PNG or JPEG) with silence – e.g. a standby slate.
+
+    It never ends by itself; an input that shows images decides how long
+    (e.g. the playlist's image duration).
+    """
+
+    path: str
+    kind: Literal["image"] = "image"
+
+
+@dataclass(frozen=True)
+class CardSource:
+    """A dark card with text and silence – e.g. "Up next" / <title> / "by Anna".
+
+    Like an image it never ends by itself.
+    """
+
+    title: str
+    heading: str = ""  # small, above the title
+    subtitle: str = ""  # below the title
+    kind: Literal["card"] = "card"
+
+
+MediaSource = TestSource | UriSource | FileSource | ImageSource | CardSource
+
+
+def source_to_dict(source: MediaSource) -> dict[str, Any]:
+    """The form the core sends to the output worker."""
+    if isinstance(source, FileSource):
+        uri = {"kind": "uri", "uri": Path(source.path).resolve().as_uri()}
+        return {**uri, "cut": True} if source.cut else uri
+    if isinstance(source, ImageSource):
+        return {"kind": "image", "path": str(Path(source.path).resolve())}
+    if isinstance(source, UriSource):
+        uri = {"kind": "uri", "uri": source.uri}
+        return {**uri, "audio_uri": source.audio_uri} if source.audio_uri else uri
+    return asdict(source)
+
+
+@dataclass
+class Metadata:
+    """What is playing right now (F-IN-06); shown on the viewer page and in overlays."""
+
+    title: str = ""
+    channel: str = ""
+    thumbnail: str = ""
+    duration_s: float | None = None
+    submitter: str = ""
+
+
+@dataclass(frozen=True)
+class Viewer:
+    """Who sent a viewer form: a device id (browser cookie) and the LAN address."""
+
+    device: str
+    ip: str
+
+
+@dataclass(frozen=True)
+class ViewerItem:
+    """One line the input shows on the viewer page, e.g. a queue entry."""
+
+    id: str
+    text: str
+    detail: str = ""
+
+
+class Rejected(Exception):
+    """Raised in on_viewer_submit(): the message is shown to the viewer as it is."""
+
+
+@dataclass
+class PlaybackEvent:
+    """Sent to the plugin when its source starts, ends or fails on an output."""
+
+    kind: Literal["started", "ended", "failed"]
+    detail: str = ""
+
+
+# --- What the system gives a plugin -----------------------------------------------
+
+
+class Store:
+    """A small persistent key-value store per plugin instance (JSON file)."""
+
+    def __init__(self, path: Path):
+        self._path = path
+        self._data: dict[str, Any] = json.loads(path.read_text()) if path.exists() else {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+        self._path.write_text(json.dumps(self._data))
+
+
+@dataclass
+class PluginContext:
+    instance_id: str
+    data_dir: Path
+    log: logging.Logger
+    store: Store
+    _publish_metadata: Callable[[Metadata], None] = field(repr=False)
+    _request_next: Callable[[], None] = field(repr=False, default=lambda: None)
+    _publish_info: Callable[[str], None] = field(repr=False, default=lambda _text: None)
+    _publish_changed: Callable[[], None] = field(repr=False, default=lambda: None)
+
+    def set_metadata(self, metadata: Metadata) -> None:
+        """Publishes what is playing now."""
+        self._publish_metadata(metadata)
+
+    def next_source(self) -> None:
+        """Asks for get_source() to be called again while this input stays on air.
+
+        For inputs with several items (a playlist): when an item has ended and
+        no other input takes over, the next item follows without a gap.
+        """
+        self._request_next()
+
+    def set_info(self, text: str) -> None:
+        """A short status line for the admin page, e.g. "3 videos waiting · yt-dlp 2026.10.1"."""
+        self._publish_info(text)
+
+    def changed(self) -> None:
+        """Tells the pages that viewer_items() changed (e.g. a new queue entry)."""
+        self._publish_changed()
+
+
+# --- The plugin base class ------------------------------------------------------------
+
+
+class NoSettings(BaseModel):
+    pass
+
+
+class InputPlugin[S: BaseModel]:
+    """Base class of every input plugin. Override what you need.
+
+    Required: get_source(). Usually also is_active(). Everything else has a
+    sensible default.
+    """
+
+    Settings: ClassVar[type[BaseModel]] = NoSettings
+    #: How often the default watch_active() calls is_active() (F-AKT-02).
+    poll_interval_s: ClassVar[float] = 5.0
+    #: A form viewers can send from the player page (F-IN-04), e.g. "submit a link".
+    #: The page builds it from the model's JSON Schema; see on_viewer_submit().
+    ViewerForm: ClassVar[type[BaseModel] | None] = None
+    #: Heading of the form and its list on the player page.
+    viewer_title: ClassVar[str] = ""
+
+    def __init__(self, ctx: PluginContext, settings: S):
+        self.ctx = ctx
+        self.settings = settings
+
+    async def start(self) -> None:
+        """Called once after creation, before anything else."""
+
+    async def stop(self) -> None:
+        """Called once before the process ends."""
+
+    async def is_active(self) -> bool:
+        """Whether the input has something to show right now."""
+        return True
+
+    async def watch_active(self) -> AsyncIterator[bool]:
+        """Yields the activity whenever it changes.
+
+        The default polls is_active(). Override it to push changes at once,
+        e.g. from a websocket or a queue (F-AKT-02).
+        """
+        last: bool | None = None
+        while True:
+            active = await self.is_active()
+            if active != last:
+                yield active
+                last = active
+            await asyncio.sleep(self.poll_interval_s)
+
+    async def get_source(self) -> MediaSource:
+        """What to play when this input goes on air."""
+        raise NotImplementedError
+
+    async def can_release(self) -> bool:
+        """On equal priority: may another input take over now? (e.g. "video has ended")"""
+        return True
+
+    async def on_playback(self, event: PlaybackEvent) -> None:
+        """Called when this input's source starts, ends or fails on air."""
+
+    async def on_viewer_submit(self, form: BaseModel, viewer: Viewer) -> str:
+        """A viewer sent the ViewerForm. Return a message for them, or raise Rejected."""
+        raise Rejected("this input takes no submissions")
+
+    async def viewer_items(self) -> list[ViewerItem]:
+        """Lines shown under the form on the player page (e.g. the queue)."""
+        return []
+
+    async def remove_item(self, item_id: str) -> None:
+        """The admin removes one of the viewer_items() (e.g. a queue entry)."""

lanstreamer_sdk/scaffold.py

@@ -0,0 +1,114 @@
+"""`python -m lanstreamer_sdk new`: a new plugin folder that works from the first minute."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from lanstreamer_sdk.manifest import ID_PATTERN, ManifestError, check_id_is_free
+
+_MANIFEST = """\
+id = "@ID@"
+name = @NAME@
+version = "0.1.0"
+api_version = 1
+entry = "@MODULE@:Plugin"
+description = "One sentence for the admin page."
+# requirements = ["requests>=2.32"]  # packages from PyPI, installed at upload
+"""
+
+_MODULE = '''\
+"""@TITLE@ – an input plugin for lan-streamer (plugin API 1).
+
+It already runs: it is always active and plays a test picture. Replace is_active()
+and get_source() with your source, e.g. `return UriSource(self.settings.url)`.
+"""
+
+from pydantic import BaseModel, Field
+
+from lanstreamer_sdk import InputPlugin, Metadata, TestSource
+
+
+class Settings(BaseModel):
+    # the admin page builds its form from this model
+    pattern: str = Field("smpte", description="Test picture: smpte, colors, ball, snow, ...")
+
+
+class Plugin(InputPlugin[Settings]):
+    Settings = Settings
+
+    async def is_active(self) -> bool:
+        """Do I have something to show right now? Asked every poll_interval_s seconds."""
+        return True
+
+    async def get_source(self):
+        """What should be played when this input goes on air?"""
+        self.ctx.set_metadata(Metadata(title=@NAME@))
+        return TestSource(pattern=self.settings.pattern)
+'''
+
+_CONFTEST = """\
+import sys
+from pathlib import Path
+
+# the plugin module sits in the folder above, as in lan-streamer's plugin process
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+"""
+
+_TEST = """\
+import asyncio
+
+from @MODULE@ import Plugin, Settings
+
+from lanstreamer_sdk import TestSource
+from lanstreamer_sdk.testing import make_context
+
+
+def test_plays_the_test_picture(tmp_path):
+    async def steps():
+        ctx, seen = make_context(tmp_path)
+        plugin = Plugin(ctx, Settings(pattern="ball"))
+        await plugin.start()
+        assert await plugin.is_active()
+        assert await plugin.get_source() == TestSource(pattern="ball")
+        assert seen.metadata[-1].title == @NAME@
+
+    asyncio.run(steps())
+"""
+
+
+def module_name(plugin_id: str) -> str:
+    """Always ends in _plugin, so that it cannot shadow a package the plugin imports."""
+    name = plugin_id.replace("-", "_")
+    if not name.endswith("_plugin"):
+        name += "_plugin"
+    return f"plugin_{name}" if name[0].isdigit() else name
+
+
+def new_plugin(folder: Path, name: str = "") -> Path:
+    """Creates a working plugin in folder; its name is the plugin's id. Returns the module file."""
+    plugin_id = folder.resolve().name
+    if not ID_PATTERN.match(plugin_id):
+        raise ManifestError(
+            f"'{plugin_id}' cannot be a plugin id: 2–49 characters, a-z, 0-9 and '-', "
+            "starting with a letter or digit"
+        )
+    check_id_is_free(plugin_id)
+    if folder.exists() and any(folder.iterdir()):
+        raise ManifestError(f"{folder} already exists and is not empty")
+
+    module = module_name(plugin_id)
+    title = name or plugin_id.replace("-", " ").capitalize()
+    def fill(template: str) -> str:
+        return (template.replace("@ID@", plugin_id).replace("@MODULE@", module)
+                .replace("@NAME@", json.dumps(title, ensure_ascii=False)).replace("@TITLE@", title))  # fmt: skip
+
+    (folder / "tests").mkdir(parents=True, exist_ok=True)
+    for path, template in (
+        (folder / "plugin.toml", _MANIFEST),
+        (folder / f"{module}.py", _MODULE),
+        (folder / "tests" / "conftest.py", _CONFTEST),
+        (folder / "tests" / f"test_{module}.py", _TEST),
+    ):
+        path.write_text(fill(template), encoding="utf-8")
+    return folder / f"{module}.py"

lanstreamer_sdk/testing.py

@@ -0,0 +1,56 @@
+"""Helpers to test a plugin without lan-streamer running (e.g. with pytest).
+
+    from lanstreamer_sdk.testing import make_context
+
+    async def test_title(tmp_path):
+        ctx, seen = make_context(tmp_path)
+        plugin = Plugin(ctx, Settings())
+        await plugin.start()
+        source = await plugin.get_source()
+        assert seen.metadata[-1].title == "…"
+
+The plugin talks to the context exactly as in lan-streamer; `seen` records what
+it published. To test it in a real plugin process, see docs/plugin-guide.md.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from lanstreamer_sdk.plugin import Metadata, PluginContext, Store
+
+
+@dataclass
+class Recorded:
+    """What a plugin published through its context, oldest first."""
+
+    metadata: list[Metadata] = field(default_factory=list)
+    info: list[str] = field(default_factory=list)
+    next_requests: int = 0  # ctx.next_source() calls
+    changes: int = 0  # ctx.changed() calls
+
+
+def make_context(data_dir: Path, instance_id: str = "test") -> tuple[PluginContext, Recorded]:
+    """A PluginContext with its own data folder and store, recording what is published."""
+    data_dir.mkdir(parents=True, exist_ok=True)
+    seen = Recorded()
+
+    def request_next() -> None:
+        seen.next_requests += 1
+
+    def changed() -> None:
+        seen.changes += 1
+
+    ctx = PluginContext(
+        instance_id=instance_id,
+        data_dir=data_dir,
+        log=logging.getLogger(instance_id),
+        store=Store(data_dir / "store.json"),
+        _publish_metadata=seen.metadata.append,
+        _request_next=request_next,
+        _publish_info=lambda text: seen.info.append(str(text)),
+        _publish_changed=changed,
+    )
+    return ctx, seen

lanstreamer_sdk/tools.py

@@ -0,0 +1,112 @@
+"""Tools for plugin authors: start a plugin, check its folder, pack it for the upload.
+
+    python -m lanstreamer_sdk new <folder> [--name '<display name>']
+        creates a working plugin; the folder's name becomes the plugin's id.
+    python -m lanstreamer_sdk check <folder> [--settings '<json>']
+        loads the plugin like lan-streamer does and prints its settings form
+        (JSON Schema), the validated settings and its viewer form, or the error.
+    python -m lanstreamer_sdk pack <folder> [-o <file.zip>]
+        zips the plugin for the admin page (Plugins → Upload), without caches,
+        tests and installed requirements.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import sys
+import zipfile
+from pathlib import Path
+from typing import Any
+
+from pydantic import ValidationError
+
+from lanstreamer_sdk.manifest import ManifestError, check_id_is_free, load_manifest
+from lanstreamer_sdk.plugin import InputPlugin
+from lanstreamer_sdk.scaffold import new_plugin
+
+DEPS = ".deps"  # requirements installed at upload (lanstreamer/plugins/install.py)
+# never in the upload: caches, installed requirements, the plugin's own tests
+SKIP_DIRS = {"__pycache__", DEPS, "tests", ".git", ".venv", "venv", ".pytest_cache", ".ruff_cache"}
+SKIP_SUFFIXES = {".pyc", ".pyo", ".zip"}
+
+
+def load_plugin(folder: Path) -> type[InputPlugin]:
+    """Imports the plugin class named in folder/plugin.toml (its `entry`)."""
+    manifest = load_manifest(folder)
+    module_name, class_name = manifest.entry.split(":")
+    sys.path.insert(0, str(folder))
+    if (folder / DEPS).is_dir():
+        sys.path.insert(0, str(folder / DEPS))
+    cls = getattr(importlib.import_module(module_name), class_name)
+    if not (isinstance(cls, type) and issubclass(cls, InputPlugin)):
+        raise ManifestError(f"{manifest.entry} is not an InputPlugin")
+    return cls
+
+
+def check(folder: Path, settings: dict[str, Any] | None = None) -> dict[str, Any]:
+    """What the admin page gets from the plugin; raises on a broken plugin."""
+    manifest = load_manifest(folder)
+    check_id_is_free(manifest.id)
+    cls = load_plugin(folder)
+    result: dict[str, Any] = {
+        "id": manifest.id, "version": manifest.version, "api_version": manifest.api_version,
+        "schema": cls.Settings.model_json_schema(), "errors": [],
+        "viewer_form": None if cls.ViewerForm is None else {
+            "title": cls.viewer_title, "schema": cls.ViewerForm.model_json_schema(),
+        },
+    }  # fmt: skip
+    try:
+        result["settings"] = cls.Settings.model_validate(settings or {}).model_dump(mode="json")
+    except ValidationError as exc:
+        result["errors"] = [
+            {"field": ".".join(str(p) for p in e["loc"]), "message": e["msg"]} for e in exc.errors()
+        ]
+    return result
+
+
+def pack(folder: Path, out: Path | None = None) -> Path:
+    """Zips the plugin folder (plugin.toml at the top of the zip)."""
+    manifest = load_manifest(folder)
+    check_id_is_free(manifest.id)
+    out = out or folder.parent / f"{manifest.id}-{manifest.version}.zip"
+    files = sorted(
+        p for p in folder.rglob("*")
+        if p.is_file() and p.suffix not in SKIP_SUFFIXES
+        and not any(part in SKIP_DIRS for part in p.relative_to(folder).parts[:-1])
+    )  # fmt: skip
+    with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as archive:
+        for path in files:
+            archive.write(path, path.relative_to(folder).as_posix())
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m lanstreamer_sdk", description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)  # fmt: skip
+    commands = parser.add_subparsers(dest="command", required=True)
+    new_cmd = commands.add_parser("new", help="create a working plugin in a new folder")
+    new_cmd.add_argument("folder", type=Path)
+    new_cmd.add_argument("--name", default="", help="display name in the admin page")
+    check_cmd = commands.add_parser("check", help="load the plugin and show its forms")
+    check_cmd.add_argument("folder", type=Path)
+    check_cmd.add_argument("--settings", default="{}", help="settings to validate, as JSON")
+    pack_cmd = commands.add_parser("pack", help="zip the plugin for the upload")
+    pack_cmd.add_argument("folder", type=Path)
+    pack_cmd.add_argument("-o", "--output", type=Path)
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command == "new":
+            print(f"created {new_plugin(args.folder, args.name)}")
+            return 0
+        if args.command == "check":
+            result = check(args.folder, json.loads(args.settings))
+            print(json.dumps(result, indent=2))
+            return 1 if result["errors"] else 0
+        print(pack(args.folder, args.output))
+        return 0
+    except (ManifestError, ImportError, AttributeError, ValueError) as exc:
+        print(f"error: {exc.__class__.__name__}: {exc}", file=sys.stderr)
+        return 2

lanstreamer_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.5
+Name: lanstreamer-sdk
+Version: 1.0.0
+Summary: Write input plugins for lan-streamer
+Project-URL: Guide, https://github.com/zGLados/lan-streamer/blob/main/docs/plugin-guide.md
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.7
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# lanstreamer-sdk
+
+Write input plugins for [lan-streamer](https://github.com/zGLados/lan-streamer) without installing lan-streamer itself.
+
+```
+python -m lanstreamer_sdk new my-plugin     # a working plugin in a new folder
+python -m lanstreamer_sdk check my-plugin   # loads it like lan-streamer, shows the forms
+python -m pytest my-plugin                  # its tests
+python -m lanstreamer_sdk pack my-plugin    # the zip for the admin page (Plugins → Upload)
+```
+
+Read the [plugin guide](https://github.com/zGLados/lan-streamer/blob/main/docs/plugin-guide.md). The major version of this package is the plugin API version.

lanstreamer_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+lanstreamer_sdk/__init__.py,sha256=wb5iLdeJh-b04uk2Uc_Y2pzAdfJ7qIyatH-hUAbEzSg,1512
+lanstreamer_sdk/__main__.py,sha256=Yj1SZbo4ZEpQU2J--dIETYguOL7HRdh_ru8GUv3s7nE,69
+lanstreamer_sdk/manifest.py,sha256=nyCQF9DAisjcMbcO7Mkoi60_gsiMxx6Y7HdKxdQPH7o,2808
+lanstreamer_sdk/plugin.py,sha256=IRE3j4On7XhmerPdHzQZKY5fF1hwyVZ7U0lDZrs0gyo,7941
+lanstreamer_sdk/scaffold.py,sha256=7vV-Xisoq6h3ZjUyBTI7CWguKpypWz7T4iR_NwDXdYk,3752
+lanstreamer_sdk/testing.py,sha256=NMPNioAkSIs0d4Sz6VkOifnEdnHp_FQgCfceDHyU3Yg,1787
+lanstreamer_sdk/tools.py,sha256=YeS068hA1xMMv_lhvJotpPSUHXdQ4SBEQUhhr6Km-Bs,5031
+lanstreamer_sdk-1.0.0.dist-info/METADATA,sha256=PbFpI8zJAmRHGmaTLoXW-Aeq6AGJllsX42jvZJUit60,1003
+lanstreamer_sdk-1.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+lanstreamer_sdk-1.0.0.dist-info/RECORD,,

lanstreamer_sdk-1.0.0.dist-info/WHEEL

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