omniplayr-plugins 2026.7.0__tar.gz

omniplayr_plugins-2026.7.0/.gitignore

@@ -0,0 +1,30 @@
+# Dependencies
+node_modules/
+
+# Build output
+dist/
+build/
+coverage/
+
+# Cache
+__pycache__
+
+# TypeScript
+*.tsbuildinfo
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Environment files
+.env
+.env.*
+
+# Editor / OS
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db

omniplayr_plugins-2026.7.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: omniplayr-plugins
+Version: 2026.7.0
+Summary: Backend development SDK for OmniPlayr plugins.
+Project-URL: Homepage, https://omniplayr.wokki20.nl/
+Project-URL: Documentation, https://omniplayr.wokki20.nl/docs/plugins/building/backend/
+Project-URL: Repository, https://github.com/OmniPlayr/OmniPlayr-plugin-SDK
+Project-URL: Issues, https://github.com/OmniPlayr/OmniPlayr-plugin-SDK/issues
+Author: OmniPlayr
+License-Expression: MIT
+Keywords: omniplayr,plugins,sdk,typing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# omniplayr-plugins
+
+Backend development SDK for OmniPlayr plugins.
+
+Install it in a plugin development environment:
+
+```powershell
+pip install omniplayr-plugins
+```
+
+Plugin authors can import the public backend SDK from one namespace:
+
+```python
+from omniplayr.plugins import BackendPlugin, api, register
+```
+
+This package is intentionally lightweight. It provides type hints, typed
+placeholders, protocols, docstrings, and IDE autocomplete support for backend
+plugin development. The actual runtime implementation is provided by the
+OmniPlayr server and Docker runtime when a plugin is loaded.
+
+## Documentation
+
+Read the full backend plugin documentation:
+
+https://omniplayr.wokki20.nl/docs/plugins/building/backend/#backend-plugin-overview
+
+## API Map
+
+- `BackendPlugin`, `PluginBase`, `register`, `get_plugin`, `get_backend_plugin_dir`,
+  `get_plugin_router`, `load_plugins`
+  [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/#the-setup-function)
+
+- `api`, `PluginApi`, `RouteHandler`, `RouteDecorator`
+  [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/routes.html#registering-routes)
+
+- `PluginFunctions`, `expose`, `expose_function`, `call`, `call_plugin_function`,
+  `is_installed`, `is_plugin_available`, `has_function`,
+  `is_plugin_function_available`, `mark_plugin_loaded`, `remove_plugin`,
+  `PluginNotAvailableError`,
+  `PluginFunctionNotFoundError`
+  [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#available-helpers)
+
+- `get_plugin_config`, `reload_plugin_config`, `flatten_plugin_configs`,
+  `get_config`, `load_configs`, `flatten_configs`, `flatten_frontend_configs`,
+  `TomlValue`, `FlatConfigItem`, `deep_merge`, `sync_config`,
+  `start_config_watcher`, `ConfigChangeHandler`
+
+- `request_db_access`, `PluginDB`, `ProtectionLevel`, `get_conn`,
+  `is_safe_sql_identifier`, `parse_column_type`, `can_convert_column`,
+  `init_db`, `init_db_when_ready`
+
+- `verify_auth`, `verify_admin`, `verify_token`, `get_admin_status`,
+  `match_account`, `get_token_user`, `create_access_token`, `parse_interval`
+
+- `list_accounts`, `get_account`, `create_account`, `update_account`,
+  `delete_account`, account tokens, password verification, and two-factor
+  helpers
+
+- `notify`, `notify_once`, `notify_sync`, `notify_once_sync`,
+  `get_notifications`, `get_unread_count`, `mark_read`,
+  `delete_notification`, `NotificationManager`
+
+- `log`, `log_exception`, `get_logs`, exception hook setup helpers,
+  diagnostics helpers, `health`, `ServiceStatus`, `HealthResponse`
+
+- `fetch_plugin_info`, `install_plugin`, `install_local_plugin`,
+  `check_for_updates`, `apply_update`, `start_https_proxy`, `user_warn`
+
+## Local Testing
+
+From this package:
+
+```powershell
+python -m pip install -e .
+python - <<'PY'
+from omniplayr.plugins import BackendPlugin, api, register
+
+class MyPlugin(BackendPlugin):
+    source_type = "example"
+
+register(MyPlugin())
+
+@api.get("/health")
+def health() -> dict[str, str]:
+    return {"ok": "true"}
+
+print("omniplayr.plugins import OK")
+PY
+```
+
+The SDK exports a PEP 561 `py.typed` marker so type checkers such as Pylance,
+Pyright, and mypy can understand the package.
+
+## Deprecation Policy
+
+Backend SDK APIs should be deprecated before they are removed. When an API is
+being replaced, the OmniPlayr server should keep a compatibility wrapper with
+metadata at the top of the docstring:
+
+```python
+def old_helper() -> None:
+    """@deprecated=true
+    Use `new_helper` instead.
+    """
+```
+
+The SDK generator records the first backend version where the marker appears in
+`backend/deprecations.json`, then renders the SDK docstring as a normal
+deprecation notice. You can also pin the version manually:
+
+```python
+def old_helper() -> None:
+    """@deprecated=true
+    @deprecated_since=2026.7.2
+    Use `new_helper` instead.
+    """
+```
+
+Deprecated APIs remain exported by this SDK for at least one year. They are only
+removed during an annual major compatibility cleanup, so plugin authors have a
+full yearly release window to migrate.

omniplayr_plugins-2026.7.0/README.md

@@ -0,0 +1,122 @@
+# omniplayr-plugins
+
+Backend development SDK for OmniPlayr plugins.
+
+Install it in a plugin development environment:
+
+```powershell
+pip install omniplayr-plugins
+```
+
+Plugin authors can import the public backend SDK from one namespace:
+
+```python
+from omniplayr.plugins import BackendPlugin, api, register
+```
+
+This package is intentionally lightweight. It provides type hints, typed
+placeholders, protocols, docstrings, and IDE autocomplete support for backend
+plugin development. The actual runtime implementation is provided by the
+OmniPlayr server and Docker runtime when a plugin is loaded.
+
+## Documentation
+
+Read the full backend plugin documentation:
+
+https://omniplayr.wokki20.nl/docs/plugins/building/backend/#backend-plugin-overview
+
+## API Map
+
+- `BackendPlugin`, `PluginBase`, `register`, `get_plugin`, `get_backend_plugin_dir`,
+  `get_plugin_router`, `load_plugins`
+  [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/#the-setup-function)
+
+- `api`, `PluginApi`, `RouteHandler`, `RouteDecorator`
+  [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/routes.html#registering-routes)
+
+- `PluginFunctions`, `expose`, `expose_function`, `call`, `call_plugin_function`,
+  `is_installed`, `is_plugin_available`, `has_function`,
+  `is_plugin_function_available`, `mark_plugin_loaded`, `remove_plugin`,
+  `PluginNotAvailableError`,
+  `PluginFunctionNotFoundError`
+  [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#available-helpers)
+
+- `get_plugin_config`, `reload_plugin_config`, `flatten_plugin_configs`,
+  `get_config`, `load_configs`, `flatten_configs`, `flatten_frontend_configs`,
+  `TomlValue`, `FlatConfigItem`, `deep_merge`, `sync_config`,
+  `start_config_watcher`, `ConfigChangeHandler`
+
+- `request_db_access`, `PluginDB`, `ProtectionLevel`, `get_conn`,
+  `is_safe_sql_identifier`, `parse_column_type`, `can_convert_column`,
+  `init_db`, `init_db_when_ready`
+
+- `verify_auth`, `verify_admin`, `verify_token`, `get_admin_status`,
+  `match_account`, `get_token_user`, `create_access_token`, `parse_interval`
+
+- `list_accounts`, `get_account`, `create_account`, `update_account`,
+  `delete_account`, account tokens, password verification, and two-factor
+  helpers
+
+- `notify`, `notify_once`, `notify_sync`, `notify_once_sync`,
+  `get_notifications`, `get_unread_count`, `mark_read`,
+  `delete_notification`, `NotificationManager`
+
+- `log`, `log_exception`, `get_logs`, exception hook setup helpers,
+  diagnostics helpers, `health`, `ServiceStatus`, `HealthResponse`
+
+- `fetch_plugin_info`, `install_plugin`, `install_local_plugin`,
+  `check_for_updates`, `apply_update`, `start_https_proxy`, `user_warn`
+
+## Local Testing
+
+From this package:
+
+```powershell
+python -m pip install -e .
+python - <<'PY'
+from omniplayr.plugins import BackendPlugin, api, register
+
+class MyPlugin(BackendPlugin):
+    source_type = "example"
+
+register(MyPlugin())
+
+@api.get("/health")
+def health() -> dict[str, str]:
+    return {"ok": "true"}
+
+print("omniplayr.plugins import OK")
+PY
+```
+
+The SDK exports a PEP 561 `py.typed` marker so type checkers such as Pylance,
+Pyright, and mypy can understand the package.
+
+## Deprecation Policy
+
+Backend SDK APIs should be deprecated before they are removed. When an API is
+being replaced, the OmniPlayr server should keep a compatibility wrapper with
+metadata at the top of the docstring:
+
+```python
+def old_helper() -> None:
+    """@deprecated=true
+    Use `new_helper` instead.
+    """
+```
+
+The SDK generator records the first backend version where the marker appears in
+`backend/deprecations.json`, then renders the SDK docstring as a normal
+deprecation notice. You can also pin the version manually:
+
+```python
+def old_helper() -> None:
+    """@deprecated=true
+    @deprecated_since=2026.7.2
+    Use `new_helper` instead.
+    """
+```
+
+Deprecated APIs remain exported by this SDK for at least one year. They are only
+removed during an annual major compatibility cleanup, so plugin authors have a
+full yearly release window to migrate.

omniplayr_plugins-2026.7.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "omniplayr-plugins"
+version = "2026.7.0"
+description = "Backend development SDK for OmniPlayr plugins."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+  { name = "OmniPlayr" }
+]
+keywords = ["omniplayr", "plugins", "sdk", "typing"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://omniplayr.wokki20.nl/"
+Documentation = "https://omniplayr.wokki20.nl/docs/plugins/building/backend/"
+Repository = "https://github.com/OmniPlayr/OmniPlayr-plugin-SDK"
+Issues = "https://github.com/OmniPlayr/OmniPlayr-plugin-SDK/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/omniplayr"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "README.md",
+  "pyproject.toml",
+  "src/omniplayr",
+]

omniplayr_plugins-2026.7.0/src/omniplayr/__init__.py

@@ -0,0 +1 @@
+"""Namespace package for OmniPlayr development SDKs."""

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/__init__.py

@@ -0,0 +1,35 @@
+"""Public backend development SDK for OmniPlayr plugins."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ._runtime import OmniPlayrRuntimeUnavailableError
+from ._runtime import runtime_unavailable
+from .account import *
+from .admin import *
+from .api import *
+from .backend_config import *
+from .config import *
+from .db import *
+from .diagnostics import *
+from .functions import *
+from .health import *
+from .installer import *
+from .logging import *
+from .notifications import *
+from .passwords import *
+from .runtime import *
+from .server import *
+from .updater import *
+
+BackendPlugin = PluginBase
+call_plugin_function = call
+is_plugin_available = is_installed
+is_plugin_function_available = has_function
+
+def expose_function(function_name: str, function: Callable[..., Any] | None = None) -> Any:
+    """Expose a callable for the current backend plugin."""
+    raise runtime_unavailable("expose_function")
+
+__all__ = ['BACKEND_PRESERVED', 'BOLD', 'BackendPlugin', 'DIM', 'FRONTEND_PRESERVED', 'HealthResponse', 'INITIAL_NOTIFICATIONS', 'LEVEL_COLORS', 'LEVEL_LABELS', 'NotificationManager', 'OmniPlayrRuntimeUnavailableError', 'PROTECTED_TABLES', 'PluginApi', 'PluginBase', 'PluginDB', 'PluginFunctionNotFoundError', 'PluginFunctions', 'PluginNotAvailableError', 'ProtectionLevel', 'RESET', 'ROOT_PRESERVED', 'RouteDecorator', 'RouteHandler', 'ServiceStatus', 'api', 'apply_update', 'call', 'call_plugin_function', 'check_for_updates', 'create_2fa_setup', 'create_access_token', 'create_account', 'create_account_token', 'create_backup_codes', 'delete_2fa', 'delete_account', 'delete_account_token', 'delete_backup_codes', 'delete_notification', 'delete_profile_picture', 'expose', 'expose_function', 'fetch_plugin_info', 'flatten_configs', 'flatten_frontend_configs', 'flatten_plugin_configs', 'get_account', 'get_account_summary', 'get_admin_status', 'get_backend_plugin_dir', 'get_config', 'get_error_counts', 'get_logs', 'get_notifications', 'get_plugin', 'get_plugin_config', 'get_plugin_router', 'get_token_user', 'get_unread_count', 'get_uptime_seconds', 'has_backup_codes', 'has_function', 'health', 'install_local_plugin', 'install_plugin', 'is_installed', 'is_plugin_available', 'is_plugin_function_available', 'list_account_summaries', 'list_accounts', 'load_configs', 'load_plugins', 'log', 'log_exception', 'mark_plugin_loaded', 'mark_read', 'match_account', 'notify', 'notify_once', 'notify_once_sync', 'notify_sync', 'parse_interval', 'password_check', 'password_hash', 'record_error', 'register', 'reload_plugin_config', 'remove_plugin', 'remove_table_protection', 'request_db_access', 'reset_error_counts', 'revoke_token', 'run_diagnostics', 'set_main_loop', 'set_table_protection', 'setup_asyncio_exception_handler', 'setup_exception_hook', 'setup_thread_exception_hook', 'start_diagnostics', 'update_account', 'verify_2fa_code', 'verify_account_password', 'verify_admin', 'verify_auth', 'verify_backup_code', 'verify_token']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/_runtime.py

@@ -0,0 +1,17 @@
+"""Runtime placeholders for the generated OmniPlayr backend SDK."""
+
+from __future__ import annotations
+
+
+class OmniPlayrRuntimeUnavailableError(RuntimeError):
+    """Raised when an OmniPlayr server-only API is used outside the runtime."""
+
+
+def runtime_unavailable(name: str) -> OmniPlayrRuntimeUnavailableError:
+    """Return an error for APIs that are only implemented by the server."""
+
+    return OmniPlayrRuntimeUnavailableError(
+        f"{name} is provided by the OmniPlayr backend runtime. "
+        "The omniplayr-plugins package only supplies development-time typing, "
+        "imports, docstrings, and autocomplete support."
+    )

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/account.py

@@ -0,0 +1,86 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `account` helpers."""
+
+def list_accounts() -> Any:
+    """Return all accounts with password state and masked sensitive fields."""
+    raise runtime_unavailable("list_accounts")
+
+def list_account_summaries() -> Any:
+    """Return account identity fields without loading large profile images."""
+    raise runtime_unavailable("list_account_summaries")
+
+def get_account_summary(account_id: int) -> Any:
+    """Return identity fields without loading profile images or account tokens."""
+    raise runtime_unavailable("get_account_summary")
+
+def get_account(account_id: int) -> Any:
+    """Return a full account record with masked account tokens, if it exists."""
+    raise runtime_unavailable("get_account")
+
+def create_account(name: str, role: str, avatar_b64: str | None) -> Any:
+    """Create an account and return the inserted account record."""
+    raise runtime_unavailable("create_account")
+
+def update_account(account_id: int, name: str | None, role: str | None, avatar_b64: str | None, nickname: str | None = ..., about: str | None = ..., password: str | None = ..., old_password: str | None = ...) -> Any:
+    """Update account profile fields, role, avatar, or password."""
+    raise runtime_unavailable("update_account")
+
+def delete_profile_picture(account_id: int) -> bool:
+    """Remove the profile picture for an account."""
+    raise runtime_unavailable("delete_profile_picture")
+
+def delete_account(account_id: int, force: bool = ...) -> bool:
+    """Delete an account, optionally bypassing last-admin protection."""
+    raise runtime_unavailable("delete_account")
+
+def verify_account_password(account_id: int, password: str) -> str:
+    """Return the password verification status for an account."""
+    raise runtime_unavailable("verify_account_password")
+
+def create_account_token(account_id: int, password_protected: bool = ..., user_agent: str | None = ..., ip_address: str | None = ...) -> Any:
+    """Create a persistent account token for an account."""
+    raise runtime_unavailable("create_account_token")
+
+def revoke_token(account_id: int, token: str | None, revoke_all: bool = ...) -> Any:
+    """Revoke one account token or all active tokens for an account."""
+    raise runtime_unavailable("revoke_token")
+
+def delete_account_token(account_id: int, token: str) -> Any:
+    """Permanently delete a revoked account token."""
+    raise runtime_unavailable("delete_account_token")
+
+def create_2fa_setup(account_id: int) -> Any:
+    """Create a two-factor authentication secret, QR code, and backup codes."""
+    raise runtime_unavailable("create_2fa_setup")
+
+def verify_2fa_code(account_id: int, code: str, allow_enabled_bypass: bool = ..., backup_code: str | None = ...) -> Any:
+    """Verify a two-factor authentication code or backup code for an account."""
+    raise runtime_unavailable("verify_2fa_code")
+
+def delete_2fa(account_id: int, code: str) -> Any:
+    """Disable two-factor authentication for an account after code verification."""
+    raise runtime_unavailable("delete_2fa")
+
+def create_backup_codes(account_id: int) -> Any:
+    """Create and store backup codes for account two-factor authentication."""
+    raise runtime_unavailable("create_backup_codes")
+
+def delete_backup_codes(account_id: int) -> Any:
+    """Delete all backup codes for an account."""
+    raise runtime_unavailable("delete_backup_codes")
+
+def verify_backup_code(account_id: int, code: str) -> Any:
+    """Verify and consume a two-factor authentication backup code."""
+    raise runtime_unavailable("verify_backup_code")
+
+def has_backup_codes(account_id: int) -> Any:
+    """Return whether an account has any backup codes available."""
+    raise runtime_unavailable("has_backup_codes")
+
+__all__ = ['create_2fa_setup', 'create_account', 'create_account_token', 'create_backup_codes', 'delete_2fa', 'delete_account', 'delete_account_token', 'delete_backup_codes', 'delete_profile_picture', 'get_account', 'get_account_summary', 'has_backup_codes', 'list_account_summaries', 'list_accounts', 'revoke_token', 'update_account', 'verify_2fa_code', 'verify_account_password', 'verify_backup_code']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/admin.py

@@ -0,0 +1,18 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `admin` helpers."""
+
+def verify_admin(auth = ..., x_account_token: str = ...) -> bool:
+    """Verify if an account has admin access based on account token."""
+    raise runtime_unavailable("verify_admin")
+
+def get_admin_status(account_id: int) -> bool:
+    """Return whether an account is an admin account based on account id."""
+    raise runtime_unavailable("get_admin_status")
+
+__all__ = ['get_admin_status', 'verify_admin']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/api.py

@@ -0,0 +1,54 @@
+"""Typed route decorators for OmniPlayr backend plugin API routes."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+RouteHandler = Callable[..., Any]
+RouteDecorator = Callable[[RouteHandler], RouteHandler]
+
+
+class PluginApi:
+    """Development-time facade for OmniPlayr backend plugin routes.
+
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/routes.html#registering-routes)
+    """
+
+    def route(self, method: str, path: str, **kwargs: Any) -> RouteDecorator:
+        """Create a typed route decorator."""
+
+        def decorator(handler: RouteHandler) -> RouteHandler:
+            return handler
+
+        return decorator
+
+    def get(self, path: str, **kwargs: Any) -> RouteDecorator:
+        """Decorate a GET route for a backend plugin."""
+
+        return self.route("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> RouteDecorator:
+        """Decorate a POST route for a backend plugin."""
+
+        return self.route("POST", path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> RouteDecorator:
+        """Decorate a PUT route for a backend plugin."""
+
+        return self.route("PUT", path, **kwargs)
+
+    def patch(self, path: str, **kwargs: Any) -> RouteDecorator:
+        """Decorate a PATCH route for a backend plugin."""
+
+        return self.route("PATCH", path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> RouteDecorator:
+        """Decorate a DELETE route for a backend plugin."""
+
+        return self.route("DELETE", path, **kwargs)
+
+
+api = PluginApi()
+
+__all__ = ["PluginApi", "RouteDecorator", "RouteHandler", "api"]

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/backend_config.py

@@ -0,0 +1,26 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `backend_config` helpers."""
+
+def load_configs() -> Any:
+    """Load and validate backend configuration files from disk."""
+    raise runtime_unavailable("load_configs")
+
+def get_config(key_path, default = ...) -> Any:
+    """Return a backend configuration value by dotted key path."""
+    raise runtime_unavailable("get_config")
+
+def flatten_configs() -> Any:
+    """Return flattened backend config metadata for UI rendering."""
+    raise runtime_unavailable("flatten_configs")
+
+def flatten_frontend_configs() -> Any:
+    """Return flattened frontend config metadata for UI rendering."""
+    raise runtime_unavailable("flatten_frontend_configs")
+
+__all__ = ['flatten_configs', 'flatten_frontend_configs', 'get_config', 'load_configs']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/config.py

@@ -0,0 +1,22 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `config` helpers."""
+
+def get_plugin_config(plugin_key: str, key_path: str, default = ...) -> Any:
+    """Return a plugin configuration value by dotted key path."""
+    raise runtime_unavailable("get_plugin_config")
+
+def reload_plugin_config(plugin_key: str) -> Any:
+    """Clear and reload cached configuration for a plugin."""
+    raise runtime_unavailable("reload_plugin_config")
+
+def flatten_plugin_configs(plugin_key: str) -> Any:
+    """Return flattened plugin config metadata for UI rendering."""
+    raise runtime_unavailable("flatten_plugin_configs")
+
+__all__ = ['flatten_plugin_configs', 'get_plugin_config', 'reload_plugin_config']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/db.py

@@ -0,0 +1,58 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `db` helpers."""
+
+ProtectionLevel = Literal['read', 'write']
+
+PROTECTED_TABLES: dict[str, ProtectionLevel] = {'accounts': 'write', 'server': 'read', 'setup_state': 'read', 'access_tokens': 'read', 'account_tokens': 'read', 'notifications': 'write', 'initial_notifications_sent': 'read', 'update_cache': 'read', 'backup_codes': 'read'}
+
+def set_table_protection(table: str, level: ProtectionLevel) -> None:
+    """Set the plugin access protection level for a database table."""
+    raise runtime_unavailable("set_table_protection")
+
+def remove_table_protection(table: str) -> None:
+    """Remove plugin access protection from a database table."""
+    raise runtime_unavailable("remove_table_protection")
+
+class PluginDB:
+    """Plugin-scoped database helper enforcing table grants and protections."""
+
+    def fetch(self, table: str, where: dict[str, Any] | None = ..., columns: list[str] | None = ..., order_by: str | None = ..., limit: int | None = ...) -> list[dict]:
+        """Fetch rows from an accessible table with optional filtering and ordering."""
+        raise runtime_unavailable("fetch")
+
+    def fetch_one(self, table: str, where: dict[str, Any], columns: list[str] | None = ...) -> dict | None:
+        """Fetch the first row matching a table filter."""
+        raise runtime_unavailable("fetch_one")
+
+    def insert(self, table: str, data: dict[str, Any]) -> dict:
+        """Insert a row into a writable table and return the inserted row."""
+        raise runtime_unavailable("insert")
+
+    def update(self, table: str, data: dict[str, Any], where: dict[str, Any]) -> int:
+        """Update rows in a writable table and return the affected row count."""
+        raise runtime_unavailable("update")
+
+    def delete(self, table: str, where: dict[str, Any]) -> int:
+        """Delete rows from a writable table and return the affected row count."""
+        raise runtime_unavailable("delete")
+
+    def count(self, table: str, where: dict[str, Any] | None = ...) -> int:
+        """Count rows in an accessible table with an optional filter."""
+        raise runtime_unavailable("count")
+
+    @property
+    def accessible_tables(self) -> dict[str, str]:
+        """Return the table grants available to this plugin."""
+        raise runtime_unavailable("accessible_tables")
+
+def request_db_access(plugin_key: str, *, own: dict[str, dict[str, str]] | None = ..., read: list[str] | None = ..., readwrite: list[str] | None = ...) -> PluginDB:
+    """Request database table grants for a backend plugin."""
+    raise runtime_unavailable("request_db_access")
+
+__all__ = ['PROTECTED_TABLES', 'PluginDB', 'ProtectionLevel', 'remove_table_protection', 'request_db_access', 'set_table_protection']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/diagnostics.py

@@ -0,0 +1,34 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `diagnostics` helpers."""
+
+def record_error(level: str) -> None:
+    """Increment the diagnostic error counter for a severity level."""
+    raise runtime_unavailable("record_error")
+
+def get_error_counts() -> dict:
+    """Return current diagnostic error counters."""
+    raise runtime_unavailable("get_error_counts")
+
+def get_uptime_seconds() -> float:
+    """Return backend process uptime in seconds."""
+    raise runtime_unavailable("get_uptime_seconds")
+
+def reset_error_counts() -> None:
+    """Reset all diagnostic error counters to zero."""
+    raise runtime_unavailable("reset_error_counts")
+
+def run_diagnostics() -> None:
+    """Run one diagnostic pass over system health signals."""
+    raise runtime_unavailable("run_diagnostics")
+
+def start_diagnostics(interval_seconds: int = ...) -> None:
+    """Start background diagnostic and event-loop lag monitors."""
+    raise runtime_unavailable("start_diagnostics")
+
+__all__ = ['get_error_counts', 'get_uptime_seconds', 'record_error', 'reset_error_counts', 'run_diagnostics', 'start_diagnostics']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/functions.py

@@ -0,0 +1,83 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `functions` helpers."""
+
+class PluginNotAvailableError(LookupError):
+    """
+    Raised when a cross-plugin call targets a plugin that is not loaded.
+    
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#handling-unavailable-functions)
+    """
+
+class PluginFunctionNotFoundError(LookupError):
+    """
+    Raised when a loaded plugin does not expose the requested function.
+    
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#handling-unavailable-functions)
+    """
+
+class PluginFunctions:
+    """Plugin-scoped helper for exposing and calling cross-plugin functions."""
+
+    def expose(self, function_name: str, function: Callable[..., Any] | None = ...) -> Any:
+        """Expose a plugin-local callable for other backend plugins."""
+        raise runtime_unavailable("expose")
+
+    def call(self, plugin_key: str, function_name: str, *args: Any, **kwargs: Any) -> Any:
+        """Call a function exposed by another backend plugin."""
+        raise runtime_unavailable("call")
+
+    def is_installed(self, plugin_key: str) -> bool:
+        """Return whether another backend plugin has been loaded."""
+        raise runtime_unavailable("is_installed")
+
+    def has_function(self, plugin_key: str, function_name: str) -> bool:
+        """Return whether another plugin exposes a named function."""
+        raise runtime_unavailable("has_function")
+
+def expose(plugin_key: str, function_name: str, function: Callable[..., Any]) -> None:
+    """
+    Expose a callable under a plugin key for cross-plugin calls.
+    
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#exposing-a-function)
+    """
+    raise runtime_unavailable("expose")
+
+def mark_plugin_loaded(plugin_key: str) -> None:
+    """Mark a plugin as loaded in the in-memory cross-plugin registry."""
+    raise runtime_unavailable("mark_plugin_loaded")
+
+def remove_plugin(plugin_key: str) -> None:
+    """Remove a plugin and its exposed functions from the registry."""
+    raise runtime_unavailable("remove_plugin")
+
+def is_installed(plugin_key: str) -> bool:
+    """
+    Return whether a plugin has been marked as loaded.
+    
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#available-helpers)
+    """
+    raise runtime_unavailable("is_installed")
+
+def has_function(plugin_key: str, function_name: str) -> bool:
+    """
+    Return whether a loaded plugin exposes a named function.
+    
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#available-helpers)
+    """
+    raise runtime_unavailable("has_function")
+
+def call(plugin_key: str, function_name: str, *args: Any, **kwargs: Any) -> Any:
+    """
+    Call a function exposed by another backend plugin.
+    
+    [View Documentation](https://omniplayr.wokki20.nl/docs/plugins/building/backend/cross-plugin-functions.html#discovering-and-calling-functions)
+    """
+    raise runtime_unavailable("call")
+
+__all__ = ['PluginFunctionNotFoundError', 'PluginFunctions', 'PluginNotAvailableError', 'call', 'expose', 'has_function', 'is_installed', 'mark_plugin_loaded', 'remove_plugin']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/health.py

@@ -0,0 +1,31 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `health` helpers."""
+
+class ServiceStatus:
+    """Health model describing one backend-related service or container."""
+    name: str
+    id: str
+    status: str
+    running: bool
+    healthy: bool
+
+class HealthResponse:
+    """Health response model returned by the backend health endpoint."""
+    status: str
+    uptime_seconds: float
+    minor_health_error: int
+    normal_health_error: int
+    critical_health_error: int
+    services: list[ServiceStatus]
+
+def health() -> HealthResponse:
+    """Return overall backend health, uptime, diagnostics, and service status."""
+    raise runtime_unavailable("health")
+
+__all__ = ['HealthResponse', 'ServiceStatus', 'health']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/installer.py

@@ -0,0 +1,22 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `installer` helpers."""
+
+def fetch_plugin_info(package_id: str) -> dict | None:
+    """Fetch plugin registry metadata for a package id."""
+    raise runtime_unavailable("fetch_plugin_info")
+
+def install_local_plugin(source_path: str, target: str, package_id: str | None = ..., mode: str = ...) -> dict:
+    """Register or link a local plugin during development mode."""
+    raise runtime_unavailable("install_local_plugin")
+
+def install_plugin(package_id: str, version: str | None, target: str | None) -> dict:
+    """Download and install a plugin from the configured registry."""
+    raise runtime_unavailable("install_plugin")
+
+__all__ = ['fetch_plugin_info', 'install_local_plugin', 'install_plugin']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/logging.py

@@ -0,0 +1,44 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `logging` helpers."""
+
+LEVEL_COLORS = {'debug': '\x1b[38;5;244m', 'info': '\x1b[38;5;117m', 'success': '\x1b[38;5;82m', 'warning': '\x1b[38;5;214m', 'warn': '\x1b[38;5;214m', 'error': '\x1b[38;5;196m', 'critical': '\x1b[38;5;201m', 'diag': '\x1b[38;5;51m', 'warning_diagnostic': '\x1b[38;5;220m', 'error_diagnostic': '\x1b[38;5;208m', 'critical_diagnostic': '\x1b[38;5;199m'}
+
+RESET = '\x1b[0m'
+
+BOLD = '\x1b[1m'
+
+DIM = '\x1b[2m'
+
+LEVEL_LABELS = {'debug': 'DBG', 'info': 'INF', 'success': 'SUC', 'warning': 'WRN', 'warn': 'WRN', 'error': 'ERR', 'critical': 'CRT', 'diag': 'DIG', 'warning_diagnostic': 'WDG', 'error_diagnostic': 'EDG', 'critical_diagnostic': 'CDG'}
+
+def log(message: str, level: str = ..., source: str | None = ...) -> None:
+    """Write a structured OmniPlayr log message to console and log files."""
+    raise runtime_unavailable("log")
+
+def log_exception(exc: Exception, message: str = ..., source: str | None = ...) -> None:
+    """Log an exception with optional context and traceback information."""
+    raise runtime_unavailable("log_exception")
+
+def setup_exception_hook() -> None:
+    """Install a process-wide hook for uncaught exceptions."""
+    raise runtime_unavailable("setup_exception_hook")
+
+def setup_thread_exception_hook() -> None:
+    """Install a hook for uncaught exceptions in Python threads."""
+    raise runtime_unavailable("setup_thread_exception_hook")
+
+def setup_asyncio_exception_handler(loop: asyncio.AbstractEventLoop) -> None:
+    """Install an asyncio exception handler on an event loop."""
+    raise runtime_unavailable("setup_asyncio_exception_handler")
+
+def get_logs(since_hours: int = ..., limit: int = ..., before: str | None = ..., since: str | None = ...) -> dict:
+    """Return recent parsed log entries with basic pagination support."""
+    raise runtime_unavailable("get_logs")
+
+__all__ = ['BOLD', 'DIM', 'LEVEL_COLORS', 'LEVEL_LABELS', 'RESET', 'get_logs', 'log', 'log_exception', 'setup_asyncio_exception_handler', 'setup_exception_hook', 'setup_thread_exception_hook']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/notifications.py

@@ -0,0 +1,63 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `notifications` helpers."""
+
+INITIAL_NOTIFICATIONS: list[dict] = [{'key': 'welcome_docs', 'icon': 'BookOpenText', 'title': 'Need some help?', 'text': 'You can always read the documentation for OmniPlayr on our website.', 'action_type': 'external', 'action_url': 'https://omniplayr.wokki20.nl/docs/'}, {'key': 'welcome_message', 'icon': 'PartyPopper', 'title': 'Welcome to OmniPlayr', 'text': 'Thanks for using OmniPlayr <link href="https://omniplayr.wokki20.nl">{version}</link>!', 'action_type': None, 'action_url': None}]
+
+class NotificationManager:
+    """Manage active notification websocket connections by account."""
+
+    async def connect(self, account_id: int, ws: WebSocket) -> Any:
+        """Accept and register a websocket connection for an account."""
+        raise runtime_unavailable("connect")
+
+    def disconnect(self, account_id: int, ws: WebSocket) -> Any:
+        """Remove a websocket connection for an account."""
+        raise runtime_unavailable("disconnect")
+
+    async def send_to_user(self, account_id: int, data: dict) -> Any:
+        """Send a JSON payload to every active websocket for an account."""
+        raise runtime_unavailable("send_to_user")
+
+def get_notifications(account_id: int) -> list[dict]:
+    """Return notifications for an account ordered from newest to oldest."""
+    raise runtime_unavailable("get_notifications")
+
+def get_unread_count(account_id: int) -> int:
+    """Return the unread notification count for an account."""
+    raise runtime_unavailable("get_unread_count")
+
+def mark_read(notification_id: int, account_id: int) -> bool:
+    """Mark one notification as read for an account."""
+    raise runtime_unavailable("mark_read")
+
+def delete_notification(notification_id: int, account_id: int) -> bool:
+    """Delete one notification for an account."""
+    raise runtime_unavailable("delete_notification")
+
+async def notify(account_id: int, icon: str, title: str, text: str, action_type: str | None = ..., action_url: str | None = ...) -> dict:
+    """Create a notification and push it to active account websockets."""
+    raise runtime_unavailable("notify")
+
+async def notify_once(account_id: int, notification_key: str, icon: str, title: str, text: str, action_type: str | None = ..., action_url: str | None = ...) -> dict | None:
+    """Create a keyed notification only if it has not been sent before."""
+    raise runtime_unavailable("notify_once")
+
+def set_main_loop(loop: asyncio.AbstractEventLoop) -> None:
+    """Store the main asyncio event loop for synchronous notification helpers."""
+    raise runtime_unavailable("set_main_loop")
+
+def notify_sync(account_id: int, icon: str, title: str, text: str, action_type: str | None = ..., action_url: str | None = ...) -> None:
+    """Schedule or run notification delivery from synchronous code."""
+    raise runtime_unavailable("notify_sync")
+
+def notify_once_sync(account_id: int, notification_key: str, icon: str, title: str, text: str, action_type: str | None = ..., action_url: str | None = ...) -> None:
+    """Schedule or run keyed notification delivery from synchronous code."""
+    raise runtime_unavailable("notify_once_sync")
+
+__all__ = ['INITIAL_NOTIFICATIONS', 'NotificationManager', 'delete_notification', 'get_notifications', 'get_unread_count', 'mark_read', 'notify', 'notify_once', 'notify_once_sync', 'notify_sync', 'set_main_loop']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/passwords.py

@@ -0,0 +1,18 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `passwords` helpers."""
+
+def password_hash(password: str) -> str:
+    """Hash a plaintext password for storage."""
+    raise runtime_unavailable("password_hash")
+
+def password_check(password: str, hash: str) -> bool:
+    """Return whether a plaintext password matches a stored password hash."""
+    raise runtime_unavailable("password_check")
+
+__all__ = ['password_check', 'password_hash']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/runtime.py

@@ -0,0 +1,54 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `runtime` helpers."""
+
+class PluginBase:
+    """Base class for backend playback source plugins."""
+    source_type: str = ''
+
+    def get_stream(self, song_id: str, account_id: int) -> Any:
+        """Return a stream or file-like object for a song and account."""
+        raise runtime_unavailable("get_stream")
+
+    def get_content_type(self, song_id: str, account_id: int) -> str:
+        """Return the MIME type for a song stream."""
+        raise runtime_unavailable("get_content_type")
+
+    def get_file_size(self, song_id: str, account_id: int) -> int | None:
+        """Return the byte size for a song stream, if known."""
+        raise runtime_unavailable("get_file_size")
+
+    def get_metadata(self, song_id: str, account_id: int) -> dict:
+        """Return metadata for a song visible to the given account."""
+        raise runtime_unavailable("get_metadata")
+
+    def check_ownership(self, song_id: str, account_id: int) -> bool:
+        """Return whether the given account may access the song."""
+        raise runtime_unavailable("check_ownership")
+
+def register(plugin: PluginBase) -> Any:
+    """Register a backend playback source plugin instance."""
+    raise runtime_unavailable("register")
+
+def get_plugin(source_type: str) -> PluginBase | None:
+    """Return the registered plugin for a source type, if any."""
+    raise runtime_unavailable("get_plugin")
+
+def get_plugin_router() -> APIRouter:
+    """Return the shared FastAPI router used for plugin routes."""
+    raise runtime_unavailable("get_plugin_router")
+
+def get_backend_plugin_dir(plugin_key: str, plugin_spec: Any = ...) -> Path:
+    """Return the filesystem directory for a backend plugin key."""
+    raise runtime_unavailable("get_backend_plugin_dir")
+
+def load_plugins() -> Any:
+    """Load configured backend plugins into the current server process."""
+    raise runtime_unavailable("load_plugins")
+
+__all__ = ['PluginBase', 'get_backend_plugin_dir', 'get_plugin', 'get_plugin_router', 'load_plugins', 'register']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/server.py

@@ -0,0 +1,34 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `server` helpers."""
+
+def parse_interval(interval_str: str) -> relativedelta:
+    """Parse a human interval string into a timedelta or relativedelta."""
+    raise runtime_unavailable("parse_interval")
+
+def verify_token(access_token: str) -> Any:
+    """Validate an access token and return the stored token value."""
+    raise runtime_unavailable("verify_token")
+
+def verify_auth(creds: HTTPAuthorizationCredentials = ...) -> Any:
+    """Validate FastAPI bearer credentials for an authenticated request."""
+    raise runtime_unavailable("verify_auth")
+
+def match_account(account_id: int, account_token: str, allow_admin_force: bool = ...) -> bool:
+    """Return whether an account token belongs to an account or allowed admin."""
+    raise runtime_unavailable("match_account")
+
+def get_token_user(token: str) -> Any:
+    """Return the account id associated with an active account token."""
+    raise runtime_unavailable("get_token_user")
+
+async def create_access_token(password_protected: bool, cur: object, only_access_token: bool = ...) -> dict:
+    """Create access and refresh tokens using configured token lifetimes."""
+    raise runtime_unavailable("create_access_token")
+
+__all__ = ['create_access_token', 'get_token_user', 'match_account', 'parse_interval', 'verify_auth', 'verify_token']

omniplayr_plugins-2026.7.0/src/omniplayr/plugins/updater.py

@@ -0,0 +1,24 @@
+# This file is generated from the OmniPlayr server backend.
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from ._runtime import runtime_unavailable
+
+"""Generated SDK stubs for OmniPlayr backend `updater` helpers."""
+
+ROOT_PRESERVED = {'backend', 'frontend', '.git', '.github', '.gitignore', '.gitattributes', 'README.md', 'docker-compose.yml', 'db', 'logs', 'user_storage', '.env'}
+
+BACKEND_PRESERVED = {'plugins', 'config', 'config.local.json', 'logs', '.safe_mode'}
+
+FRONTEND_PRESERVED = {}
+
+def check_for_updates(force: bool = ...) -> dict:
+    """Check GitHub for available backend or frontend updates."""
+    raise runtime_unavailable("check_for_updates")
+
+def apply_update() -> dict:
+    """Download and apply the latest available OmniPlayr update."""
+    raise runtime_unavailable("apply_update")
+
+__all__ = ['BACKEND_PRESERVED', 'FRONTEND_PRESERVED', 'ROOT_PRESERVED', 'apply_update', 'check_for_updates']