webapp-shell 0.1__py3-none-any.whl

webapp_shell/shell.py

@@ -0,0 +1,119 @@
+"""The shell contract. A concrete shell only knows how to show a window; everything else lives here."""
+
+import time
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+
+from .backend_process import BackendError, BackendProcess
+from .json_types import JsonObject
+from .native.registry import NativeRegistry
+from .native.standard import standard_functions
+from .preferences import ShellPreferences
+from .settings import Settings
+from .smoke import SmokeReport
+from .splash import SplashPage
+from .watchdog import BackendWatchdog
+
+
+class Shell(ABC):
+    """Template: show a splash at once, start the backend off the UI thread, then show the frontend.
+
+    `boot()` runs on a worker thread, so every method it calls on a subclass must be safe to call from there.
+    """
+
+    name: str = "shell"
+
+    def __init__(
+        self,
+        settings: Settings,
+        backend: BackendProcess,
+        preferences: ShellPreferences | None = None,
+        smoke: bool = False,
+    ):
+        self.settings = settings
+        self.preferences = preferences or ShellPreferences(None)
+        self.backend = backend
+        self.smoke = smoke
+        self.backend_version: JsonObject = {}
+        self.failed = False
+        self.splash = SplashPage(settings.identity.name, settings.icon_png, settings.boot_colors)
+        self.watchdog = BackendWatchdog(backend, self.report_error, settings.identity.name, settings.config.messages)
+        self.native = NativeRegistry((*standard_functions(), *settings.config.native_functions))
+
+    @property
+    def window_title(self) -> str:
+        """The program's name. Running from the source it also names the shell and the backend version, for the team."""
+
+        name = self.settings.identity.name
+        if self.settings.installation.frozen:
+            return name
+        return f"{name} ({self.name}) · backend {self.backend_version.get('version', '?')}"
+
+    def run(self) -> int:
+        try:
+            self.event_loop(self.boot)
+        finally:
+            self.watchdog.stop()
+            self.backend.stop()
+        return 1 if self.failed else 0
+
+    def boot(self) -> None:
+        started = time.monotonic()
+        try:
+            self.backend.start()
+            self.backend_version = self.backend.version()
+        except BackendError as error:
+            self.report_error(str(error))
+            return
+        self.hold_splash(started)
+        self.set_title(self.window_title)
+        self.navigate(self.backend.launch_url)
+        self.on_navigated()
+        if not self.smoke:
+            self.watchdog.start()
+
+    def hold_splash(
+        self,
+        started: float,
+        now: Callable[[], float] = time.monotonic,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        """Keep the splash up until `splash_seconds` have passed since `started` (the backend may be ready sooner)."""
+        remaining = self.settings.splash_seconds - (now() - started)
+        if remaining > 0:
+            sleep(remaining)
+
+    def report_error(self, message: str) -> None:
+        self.failed = True
+        print(message)
+        self.show_page(self.splash.error(message))
+        if self.smoke:
+            self.quit()
+
+    def finish_smoke(self, page: str) -> None:
+        print(SmokeReport(self.name, self.backend_version, page))
+
+    # --- what a concrete shell provides ---------------------------------------------------------
+
+    @abstractmethod
+    def event_loop(self, boot: Callable[[], None]) -> None:
+        """Show the window with the loading splash, call `boot()` on a worker thread, block until closed."""
+
+    @abstractmethod
+    def navigate(self, url: str) -> None:
+        """Load `url` in the window. Thread-safe."""
+
+    @abstractmethod
+    def show_page(self, html: str) -> None:
+        """Replace the window content with an HTML page. Thread-safe."""
+
+    @abstractmethod
+    def set_title(self, title: str) -> None:
+        """Thread-safe."""
+
+    @abstractmethod
+    def quit(self) -> None:
+        """Close the window. Thread-safe."""
+
+    def on_navigated(self) -> None:  # noqa: B027 - an optional hook, empty on purpose
+        """Hook run on the worker thread after `navigate`; shells use it for the headless self-check."""

webapp_shell/smoke.py

@@ -0,0 +1,30 @@
+"""The headless self-check both shells share: what to ask the loaded page and how to report it."""
+
+from dataclasses import dataclass
+
+from .json_types import JsonObject
+
+
+def page_probe_js(native_global: str) -> str:
+    """What to ask the loaded page: its title, whether the app rendered, and which native bridge it can see."""
+    return (
+        "JSON.stringify({"
+        "title: document.title,"
+        "rootChildren: document.getElementById('root') ? document.getElementById('root').children.length : -1,"
+        "hash: location.hash,"
+        f"native: window.{native_global} ? '{native_global}' : "
+        "(window.pywebview && window.pywebview.api ? 'pywebview' : 'none')})"
+    )
+
+
+SETTLE_SECONDS = 2.5
+
+
+@dataclass(frozen=True)
+class SmokeReport:
+    shell: str
+    backend: JsonObject
+    page: str
+
+    def __str__(self) -> str:
+        return f"{self.shell}: backend={self.backend} page={self.page}"

webapp_shell/splash.py

@@ -0,0 +1,52 @@
+"""The two pages the shell shows itself, before and instead of the frontend. Deliberately text-light: the real
+user interface (and its translations) belongs to the frontend."""
+
+import base64
+from html import escape
+from pathlib import Path
+
+from .preferences import BootColors
+
+# A soft two-glow gradient over the base colour; a project's frontend can use the same geometry for its hero.
+HERO_GRADIENT = (
+    "radial-gradient(900px 600px at 20% 10%, {glow_a} 0, transparent 60%), "
+    "radial-gradient(700px 500px at 90% 90%, {glow_b} 0, transparent 55%), {base}"
+)
+
+_PAGE = """<!doctype html><meta charset="utf-8"><title>%(title)s</title>
+<style>
+  html,body{height:100%%;margin:0}
+  body{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:18px;
+       font:15px -apple-system,'Segoe UI',system-ui,sans-serif;background:%(background)s;color:#fff}
+  .mark{width:64px;height:64px;image-rendering:auto}
+  .spin{width:26px;height:26px;border:3px solid rgba(255,255,255,.25);border-top-color:#fff;border-radius:50%%;animation:s 0.9s linear infinite}
+  @keyframes s{to{transform:rotate(360deg)}}
+  .err{max-width:520px;text-align:center;color:#ffb4ab}
+</style>
+%(icon)s%(body)s"""
+
+
+class SplashPage:
+    def __init__(self, title: str, icon_png: Path | None, colors: BootColors):
+        self._title = escape(title)
+        self._icon_png = icon_png
+        self._colors = colors
+
+    def loading(self) -> str:
+        return self._render('<div class="spin"></div>')
+
+    def error(self, message: str) -> str:
+        return self._render(f'<div class="err">{escape(message)}</div>')
+
+    def _render(self, body: str) -> str:
+        return _PAGE % {"title": self._title, "background": self._background(), "icon": self._icon_html(), "body": body}
+
+    def _background(self) -> str:
+        c = self._colors
+        return HERO_GRADIENT.format(base=c.base, glow_a=c.glow_a, glow_b=c.glow_b)
+
+    def _icon_html(self) -> str:
+        if not self._icon_png:
+            return ""
+        data = base64.b64encode(self._icon_png.read_bytes()).decode()
+        return f'<img class="mark" alt="" src="data:image/png;base64,{data}">'

webapp_shell/watchdog.py

@@ -0,0 +1,60 @@
+"""Notices when the engine has stopped by itself and starts it again, a few times, before giving up."""
+
+import threading
+import time
+from collections import deque
+from collections.abc import Callable
+
+from .backend_process import BackendError, BackendProcess
+from .messages import ENGLISH, MessageKey, ShellMessages
+
+
+class BackendWatchdog:
+    def __init__(
+        self,
+        backend: BackendProcess,
+        give_up: Callable[[str], None],
+        name: str = "the program",
+        messages: ShellMessages = ENGLISH,
+        interval: float = 1.0,
+        max_restarts: int = 3,
+        window: float = 120.0,
+        clock: Callable[[], float] = time.monotonic,
+    ):
+        self.backend, self.give_up = backend, give_up
+        self._give_up_message = messages.text(MessageKey.BACKEND_GAVE_UP, name=name)
+        self.interval, self.max_restarts, self.window = interval, max_restarts, window
+        self._clock = clock
+        self._restarts: deque[float] = deque()
+        self._stopped = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        self._thread = threading.Thread(target=self._loop, name="backend-watchdog", daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stopped.set()
+
+    def check(self) -> None:
+        """One look. A dead engine is restarted unless that already happened `max_restarts` times within `window`."""
+        if not self.backend.died:
+            return
+        now = self._clock()
+        while self._restarts and now - self._restarts[0] > self.window:
+            self._restarts.popleft()
+        if len(self._restarts) >= self.max_restarts:
+            return self._give_up(self._give_up_message)
+        self._restarts.append(now)
+        try:
+            self.backend.restart()
+        except BackendError as error:
+            self._give_up(str(error))
+
+    def _give_up(self, message: str) -> None:
+        self.stop()
+        self.give_up(message)
+
+    def _loop(self) -> None:
+        while not self._stopped.wait(self.interval):
+            self.check()

webapp_shell/webview2.py

@@ -0,0 +1,80 @@
+"""On Windows the pywebview window is drawn by the Microsoft WebView2 runtime (on Windows 11 and on most up-to-date
+Windows 10). Without it the window cannot open, and the person would see nothing at all; this finds it first, so the
+program can say what is missing in plain words."""
+
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+
+from .messages import MessageKey, ShellMessages
+
+DOWNLOAD_URL = "https://developer.microsoft.com/microsoft-edge/webview2/"
+RUNTIME_CLIENT = "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"  # how the Edge updater lists the WebView2 runtime
+NOT_INSTALLED = "0.0.0.0"
+
+
+class RegistryHive(StrEnum):
+    MACHINE = "HKEY_LOCAL_MACHINE"
+    USER = "HKEY_CURRENT_USER"
+
+
+@dataclass(frozen=True)
+class RegistryLocation:
+    hive: RegistryHive
+    subkey: str  # holds the value `pv`: the runtime's version
+
+
+RUNTIME_LOCATIONS = (
+    RegistryLocation(RegistryHive.MACHINE, rf"SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\{RUNTIME_CLIENT}"),
+    RegistryLocation(RegistryHive.MACHINE, rf"SOFTWARE\Microsoft\EdgeUpdate\Clients\{RUNTIME_CLIENT}"),
+    RegistryLocation(RegistryHive.USER, rf"Software\Microsoft\EdgeUpdate\Clients\{RUNTIME_CLIENT}"),
+)
+
+
+def read_registry_version(location: RegistryLocation) -> str | None:
+    """The runtime's version at `location`, or None when the key or the value is not there."""
+    if sys.platform != "win32":
+        return None
+    import winreg
+
+    hive = winreg.HKEY_LOCAL_MACHINE if location.hive is RegistryHive.MACHINE else winreg.HKEY_CURRENT_USER
+    try:
+        with winreg.OpenKey(hive, location.subkey) as key:
+            value, _kind = winreg.QueryValueEx(key, "pv")
+    except OSError:
+        return None
+    return value if isinstance(value, str) else None
+
+
+class Webview2Check:
+    def __init__(
+        self,
+        platform: str = sys.platform,
+        read_version: Callable[[RegistryLocation], str | None] = read_registry_version,
+    ):
+        self._platform = platform
+        self._read_version = read_version
+
+    def is_missing(self) -> bool:
+        """True only on Windows, when no WebView2 runtime is listed."""
+        if self._platform != "win32":
+            return False
+        versions = (self._read_version(location) for location in RUNTIME_LOCATIONS)
+        return not any(version and version != NOT_INSTALLED for version in versions)
+
+    def problem(self, name: str, messages: ShellMessages) -> str | None:
+        """The sentence to show when the runtime is missing, else None."""
+        if not self.is_missing():
+            return None
+        return messages.text(MessageKey.WEBVIEW2_MISSING, name=name, url=DOWNLOAD_URL)
+
+
+def show_message_box(title: str, text: str) -> None:
+    """A windowed program has no console, so a problem before any window exists is shown in the system's own box."""
+    if sys.platform == "win32":
+        import ctypes
+
+        ctypes.windll.user32.MessageBoxW(0, text, title, 0x10)  # 0x10: the error icon
+    else:
+        print(text, file=sys.stderr)

webapp_shell/webview_shell.py

@@ -0,0 +1,86 @@
+"""Shell 2: pywebview (no Qt): the operating system's own web view."""
+
+import time
+from collections.abc import Callable
+
+import webview
+
+from .backend_process import BackendProcess
+from .enums import ShellKind
+from .native.os_actions import OsActions
+from .native.webview_background import WebviewBackground
+from .native.webview_bridge import WebviewBridge
+from .native.webview_icon import WebviewIcon
+from .native.webview_window import WebviewWindow
+from .native.window import NativeContext
+from .preferences import ShellPreferences
+from .settings import Settings
+from .shell import Shell
+from .smoke import SETTLE_SECONDS, page_probe_js
+
+
+class WebviewShell(Shell):
+    name = ShellKind.WEBVIEW
+
+    def __init__(
+        self,
+        settings: Settings,
+        backend: BackendProcess,
+        preferences: ShellPreferences | None = None,
+        smoke: bool = False,
+    ):
+        super().__init__(settings, backend, preferences, smoke)
+        self._window: webview.Window | None = None
+
+    @property
+    def window(self) -> webview.Window:
+        if self._window is None:
+            raise RuntimeError("the window is not created yet")
+        return self._window
+
+    def event_loop(self, boot: Callable[[], None]) -> None:
+        native_window = WebviewWindow()
+        bridge = WebviewBridge(self.native, NativeContext(native_window, self.preferences, OsActions()))
+        window = webview.create_window(  # pyright: ignore[reportUnknownMemberType]  # pywebview's `url` is left open
+            self.settings.identity.name,
+            html=self.splash.loading(),
+            js_api=bridge,
+            background_color=self.settings.background_color,
+            width=self.settings.window_size[0],
+            height=self.settings.window_size[1],
+        )
+        if window is None:
+            raise RuntimeError("pywebview did not create the window")
+        self._window = window
+        native_window.bind(window)
+        icon = str(self.settings.window_icon) if self.settings.window_icon else None
+        background = WebviewBackground(self.settings.background_color)
+        dock_icon = WebviewIcon(self.settings.icon_png)
+
+        def start() -> None:
+            background.apply(window)
+            dock_icon.apply()
+            boot()
+
+        webview.start(
+            start, icon=icon
+        )  # `boot` runs on a worker thread once the GUI is up; the icon is a .ico on Windows, a PNG elsewhere
+
+    def navigate(self, url: str) -> None:
+        self.window.load_url(url)
+
+    def show_page(self, html: str) -> None:
+        self.window.load_html(html)
+
+    def set_title(self, title: str) -> None:
+        self.window.set_title(title)
+
+    def quit(self) -> None:
+        self.window.destroy()
+
+    def on_navigated(self) -> None:
+        if not self.smoke:
+            return
+        time.sleep(SETTLE_SECONDS)
+        self.finish_smoke(self.window.evaluate_js(page_probe_js(self.settings.identity.native_global)))
+        self.quit()

webapp_shell-0.1.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.5
+Name: webapp-shell
+Version: 0.1
+Summary: A desktop window for a web app made of a Python backend and a compiled frontend.
+Project-URL: Homepage, https://github.com/prmpsmart/webapp_shell
+Project-URL: Documentation, https://prmpsmart.github.io/webapp_shell
+Project-URL: Source, https://github.com/prmpsmart/webapp_shell
+Project-URL: Issues, https://github.com/prmpsmart/webapp_shell/issues
+Project-URL: Changelog, https://github.com/prmpsmart/webapp_shell/blob/main/CHANGE_LOG.md
+Author-email: Miracle Apata <prmpsmart@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: backend,desktop,frontend,native,python,pywebview,shell,webview
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: httpx>=0.28
+Requires-Dist: pywebview>=6.2
+Provides-Extra: backend
+Requires-Dist: starlette>=0.40; extra == 'backend'
+Provides-Extra: dev
+Requires-Dist: pyinstaller>=6; extra == 'dev'
+Requires-Dist: pyside6>=6.9; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: starlette>=0.40; extra == 'dev'
+Requires-Dist: uvicorn>=0.30; extra == 'dev'
+Provides-Extra: freeze
+Requires-Dist: pyinstaller>=6; extra == 'freeze'
+Provides-Extra: qt
+Requires-Dist: pyside6>=6.9; extra == 'qt'
+Description-Content-Type: text/markdown
+
+# webapp-shell
+
+[![CI](https://github.com/prmpsmart/webapp_shell/actions/workflows/ci.yml/badge.svg)](https://github.com/prmpsmart/webapp_shell/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/webapp-shell)](https://pypi.org/project/webapp-shell/)
+[![Python](https://img.shields.io/pypi/pyversions/webapp-shell)](https://pypi.org/project/webapp-shell/)
+[![Licence: MIT](https://img.shields.io/badge/licence-MIT-blue.svg)](LICENSE)
+[![Docs](https://img.shields.io/badge/docs-site-3556d6)](https://prmpsmart.github.io/webapp_shell)
+
+A desktop window for a web app made of a **Python backend** and a **compiled frontend**. Your project describes itself
+in one config object; the library starts the backend, waits until it is healthy, opens the frontend in a native window
+(pywebview, or Qt on request) and gives the page a small set of native functions (file and folder dialogs, reveal in the
+file manager, open a link, zoom).
+
+> Documentation: <https://prmpsmart.github.io/webapp_shell>. The same site is what `examples/site` opens in the
+> library's own window, where each feature's demonstration button does the real thing.
+>
+> By Miracle Apata ([@prmpsmart](https://github.com/prmpsmart)). MIT licence.
+
+```python
+from pathlib import Path
+
+from webapp_shell import AppIdentity, BackendSpec, BootColors, ShellConfig, WireProtocol, run
+
+ROOT = Path(__file__).resolve().parent
+
+config = ShellConfig(
+    identity=AppIdentity(
+        name="Acme Notes",
+        slug="acme",
+        storage_dir=Path.home() / ".acme",
+        boot_colors=BootColors(base="#102030", glow_a="#204060", glow_b="#4060a0"),
+    ),
+    backend=BackendSpec(module="acme_backend", wire=WireProtocol.for_slug("acme"), package_dirs=(ROOT / "backend",)),
+    source_root=ROOT,  # holds frontend/dist, the compiled frontend
+)
+
+if __name__ == "__main__":
+    raise SystemExit(run(config))
+```
+
+The backend reads the same contract with the library's helpers (Starlette or FastAPI):
+
+```python
+parser = argparse.ArgumentParser()
+add_launch_arguments(parser, config.backend)  # --port, --frontend, --preferences-file, --token
+launch = read_launch_arguments(parser, parser.parse_args(), config.backend.wire)
+app.add_middleware(TokenGuard, validator=TokenValidator(launch.token, wire), wire=wire)
+```
+
+Native functions: the standard set (file and folder dialogs, save as, reveal, open a link, zoom, boot colours) is always
+there; a project adds its own and the page calls them by name.
+
+```python
+from dataclasses import dataclass
+from webapp_shell import JsonValue, NativeContext, NativeFunction
+
+
+@dataclass(frozen=True)
+class Greeting:  # the page's arguments, in order; each is type-checked before your code runs
+    who: str
+
+
+def greet(context: NativeContext, arguments: Greeting) -> JsonValue:  # context.window, .preferences, .actions
+    return f"hello {arguments.who}"
+
+
+config = ShellConfig(..., native_functions=(NativeFunction("greet", Greeting, greet),))
+```
+
+```js
+// copy the bridge into the frontend once: python -m webapp_shell bridge --out src/
+import { getBridge } from "./webapp-shell-bridge.js";
+
+const bridge = await getBridge({ nativeGlobal: "acmeNative" });
+const path = await bridge.pickFile([{ name: "Excel", extensions: ["xlsx"] }]);
+const hello = await bridge.call("greet", "Ada");
+```
+
+Install: `pip install webapp-shell` (pywebview is included); `pip install "webapp-shell[qt]"` adds Qt, and
+`pip install "webapp-shell[backend]"` adds Starlette for the token guard.
+
+On Windows the pywebview window needs the WebView2 runtime (present on Windows 11); `pythonnet` is installed by pywebview.
+
+A runnable minimal program is in `examples/minimal/`, and `examples/site/` is the documentation website, opened by the
+library's own shell, with a live demonstration of every feature.
+
+Guides (`docs/`): [the contract](docs/CONTRACT.md), [configuration](docs/CONFIGURATION.md),
+[native functions](docs/NATIVE_FUNCTIONS.md), [freezing with PyInstaller](docs/FREEZING.md),
+[translating](docs/TRANSLATING.md), [troubleshooting](docs/TROUBLESHOOTING.md), and the generated
+[API listing](docs/API.md) (the public API: nothing that is not listed there is promised). The same guides are pages of
+the documentation site. To work on the library, read [CONTRIBUTING.md](CONTRIBUTING.md).

webapp_shell-0.1.dist-info/RECORD

@@ -0,0 +1,59 @@
+webapp_shell/__init__.py,sha256=oix7R1hN5tTcIBf4yQusfma4dVQj3KGQoyjzDzh52gM,1519
+webapp_shell/__main__.py,sha256=bj_37hL3oNMtSCalRVjFDGmUn7g6aYvflpfy4E3NJf0,2162
+webapp_shell/backend.py,sha256=Ge_BJwPL-Em3yamR9CtlDxLu9N0L6HiW6oQ22-Yq418,1391
+webapp_shell/backend_process.py,sha256=BUFG1ULeeu8n2EbGQqypioIgrRAl7B0EEgAb3BMSX_0,5418
+webapp_shell/cli.py,sha256=XorAL_WK-aDjxSF1sU1ch-eQY-TZ30getR0p0gan1_8,3414
+webapp_shell/config.py,sha256=xwttvGnV3p-66TOCuSa4Kx_CJRzkzm1EgJQY-H8KMZM,1300
+webapp_shell/enums.py,sha256=3ITML33MUF24bU_UdVO0pu1X6sdOTIK3BlvxGaLZvKI,525
+webapp_shell/identity.py,sha256=8QbetY8VtpqUniScVzdWp88C1u6UcMfzv_1o10175t8,2077
+webapp_shell/installation.py,sha256=DG3PGtkwcEr-BYFXYB_2vZgRNcRVvKdG7WPHC0dyYN8,2077
+webapp_shell/json_types.py,sha256=z0hS169QEBLsERucHjF6OMj3BU_bcKUl_itmqOaj2QI,247
+webapp_shell/library_check.py,sha256=Qewe0T596bAdkPe1CXqGxmOvBuobujOrWtTh6hI-wtU,868
+webapp_shell/messages.py,sha256=dJNgziyTm5zxlG8Jmh_sR23_9Kn_NwBQR2Zn8IYUgjI,2601
+webapp_shell/preferences.py,sha256=QiSApswZfnZKeRarqk1HcG7o_Dl4suDWb0vvKABFxyU,3070
+webapp_shell/protocol.py,sha256=en_z8aZ8EAQ1sECSV5HceSya9xLVyVysxCGzZmYNrK8,1602
+webapp_shell/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+webapp_shell/qt_shell.py,sha256=FaWYSSL9Rq3xi1iSKlz9Vrh7LxyjseqEvfjKpbV0rzo,5072
+webapp_shell/registry.py,sha256=cfdZ-qOWrjqykLvB-aA5S-pWmm_xbiVtP5jwyj-EAms,511
+webapp_shell/settings.py,sha256=DDLwM2y6krMZSzbuP-q-ssVTccLTpyYBQDbTZ-7Z3is,2683
+webapp_shell/shell.py,sha256=f2Bjg9mdbM2ymuipopdUzEfNrFul0DuOAwhMDcDREDA,4256
+webapp_shell/smoke.py,sha256=U_lnQxevLHuCLTYfJnAQsc1gkrrPA06vtXfUFj9uccs,919
+webapp_shell/splash.py,sha256=yO63XD7BU-JUTM7pwv1RKAZfYS-oWzTpqyrMYxsafr0,2153
+webapp_shell/watchdog.py,sha256=khXvB_xPy8fPcjcjxRBFLbM9AGu-DQ8Xnj3Gwy9gjqA,2098
+webapp_shell/webview2.py,sha256=f-DGvR-SYzLHZkomJeWBDTznp-eboGzbZe5yfKEQ_Zw,3053
+webapp_shell/webview_shell.py,sha256=i0IxfTgeg0WirqSuCKSf8BDKVg4znempAnPy9NUjELQ,2972
+webapp_shell/bridge/webapp-shell-bridge.d.ts,sha256=6M62jAe74dnvrsS0OyoOOosDpRFQ5MJJGbCarFMQ43I,1860
+webapp_shell/bridge/webapp-shell-bridge.js,sha256=ZJpYs82tiS7aqhS_OXWWlZf5TtYup-ueHYE1S0tf42s,4890
+webapp_shell/contract/__init__.py,sha256=JvlMHds4WVEGzE1rKfNCfCBCpmqT4Z1Llme835pL0mk,519
+webapp_shell/contract/guard.py,sha256=2_4Er6OyBvMPAXhvY48RQEIl0QwqvTQvs1H_cwyd1OY,4405
+webapp_shell/contract/launch.py,sha256=SQtLfuH1CV9wpa20ARnlazL1tSeXmwuXZLsXTlAEmEU,1920
+webapp_shell/contract/tokens.py,sha256=YK3RxGp4kiYBpzJpWVU-bsArtiP7RLzPFy6dz6YHtv8,1699
+webapp_shell/freezing/__init__.py,sha256=BmWyjr4GZuPzpZlHSxkBgkbi9xNoJF2a3Poqo7Rx0Tg,383
+webapp_shell/freezing/app.spec,sha256=ji5UEaazfgHSkbDhgQDBtoPat35zLpZInHieGp_qHOM,206
+webapp_shell/freezing/builder.py,sha256=11oaGWkxvHrm1uX5OVGkV24vC3LUWfiqXR2IJY8K4jU,4175
+webapp_shell/freezing/entry.py,sha256=ouHpSrYIIuq6Lpcjfo3EkOV5AF46gM6akPOP6PObJHE,869
+webapp_shell/freezing/plan.py,sha256=I_RzWJuU4n0Oe7lxxjGv8Cn1A0mvVQ7g8jIs27JOCHI,1800
+webapp_shell/freezing/profile.py,sha256=o80oY06P5fXZNM2yQPIOUQYHtyt3-7Ge_KpFkU1bA_o,1875
+webapp_shell/freezing/spec.py,sha256=TUHILhcFOa0i-lo6Bfs-9Y3isCocifULeQm0SZkjyJc,2299
+webapp_shell/freezing/verify.py,sha256=LeDUncKtqOC0BJTZy-Lm4-cXmX4V5bRluFXVi3aqo8M,1729
+webapp_shell/native/__init__.py,sha256=64okxF2yLE1XQrYhEl0JCaGwTK-L2oLPywavQH8GP54,206
+webapp_shell/native/arguments.py,sha256=HXew_DJJBC8C_Q_sIDaRuQ5BH7PTgUwNGKLeteyGY5o,5735
+webapp_shell/native/errors.py,sha256=bG-p4iwMYbZstJTBd0C9HJF8r2Br2ZgZDf8Lrp_Mp3c,193
+webapp_shell/native/filters.py,sha256=ybLhGmiFy7-V-gYPWPXs047KNmUVU2u92ndY4ARluzY,744
+webapp_shell/native/os_actions.py,sha256=ezphiwMGEmWb8CEyZ3QTqmgwlET5_SOgd9PXHuPXDYk,1171
+webapp_shell/native/qt_bridge.py,sha256=BtcIa2_hXenE8NuHhfw8orpEy8uQA_9L5UyCyr3mRPE,2427
+webapp_shell/native/qt_window.py,sha256=PRK5K3vTFrVe2V64Ytd8_3YnihC6apxqTxHbCcZYx6g,1427
+webapp_shell/native/registry.py,sha256=hn2J0SWAupxHjA2ufKmKoQxxbjKuvZWVEtnD6TMS130,3467
+webapp_shell/native/standard.py,sha256=NykWqjK5spwQ5z9qgrdp9Y5FhA_sLGPTz2gLCe-MBjQ,2724
+webapp_shell/native/start_location.py,sha256=5PNbAGLcWw3bCfGsC9vyxUxN9vtLpcBZjUAu8zaWS0s,1095
+webapp_shell/native/webview_background.py,sha256=OMuq8L54ku2l18Q04eqckMb28c3YQak1Yl7I5T6azuk,1744
+webapp_shell/native/webview_bridge.py,sha256=KZ10cl7oHnooBASPVBWNUuPTaLKg0tkc_6oXvc0JaGs,1098
+webapp_shell/native/webview_icon.py,sha256=lpU7RcMwWoRCIHRrEbPz3MQeoAG5FX93haFXNSFlxqg,1428
+webapp_shell/native/webview_window.py,sha256=OydIhmuyPxM3pPmQWi2FzsuqDBMZH_7mjG9_avDsT6s,1977
+webapp_shell/native/window.py,sha256=CQB1KzZvBsEuhYyojJyvcWi7z9jVOMKugpCaQLMoHuc,1045
+webapp_shell/native/zoom.py,sha256=kbIhLQ2xNljrZ-Zv3spghI6Q9-uTmt9SDgMqZOVHyGU,3667
+webapp_shell/native/zoom_range.py,sha256=cR5nvZQa7E0WvXDagPZAsBSM_U4Zg5xqHdxYXOgEIXg,330
+webapp_shell-0.1.dist-info/METADATA,sha256=1Gnx7KWsmEWEusY57rQBLN64LIB4cyb8ki9TAaqeoYA,6046
+webapp_shell-0.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+webapp_shell-0.1.dist-info/licenses/LICENSE,sha256=JKHQ_y0Zji_sAXiKzQcHaU0g0PnYKifYY87trR5Si5w,1082
+webapp_shell-0.1.dist-info/RECORD,,

webapp_shell-0.1.dist-info/WHEEL

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

webapp_shell-0.1.dist-info/licenses/LICENSE

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