genropy-asgi 0.2.0__py3-none-any.whl

genropy_asgi/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""genropy-asgi — the bridge between genro-asgi and legacy GenroPy.
+
+The generic commander/worker model lives in genro-asgi core
+(``genro_asgi.applications.multi_worker_application``); this package is the
+GenroPy-specific bridge on top of it. Three submodules, the only ``gnr.*``-aware code:
+
+- ``genropy_asgi.spa`` — the SPA bridge: ``GenropySpaApplication`` (single) and
+  ``GenropyWorkerApplication`` (pool child) host a legacy ``GnrWsgiSite``, plus the
+  ``gnrasgiserve`` CLI and the in-process register client.
+- ``genropy_asgi.proxy`` — the OpenAPI bridge: a ``GnrApp`` behind an
+  ``OpenApiApplication`` with thread-local db cleanup.
+- ``genropy_asgi.siteregister`` — the daemonless register the legacy imports as
+  ``gnr.web.daemon`` (entry-point ``gnr.web:daemon``), replacing the register daemon.
+"""
+
+__version__ = "0.2.0"

genropy_asgi/proxy/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""genropy-proxy — GenroPy legacy db behind an OpenApiApplication (collaudo).
+
+``GenropyProxyMixin`` hosts a ``GnrApp`` and closes its thread-local db
+connection via the ``route_cleanup`` hook (run in the executor thread by
+genro-asgi's ``make_callable``). ``GenropyProxyOpenApiApplication`` composes the
+mixin with ``OpenApiApplication``. The only ``gnr.*``-aware piece; everything
+REST/OpenAPI comes from genro-asgi. 
+
+"""
+
+from .genropy_proxy import GenropyProxyMixin, GenropyProxyOpenApiApplication
+
+__all__ = ["GenropyProxyMixin", "GenropyProxyOpenApiApplication"]
+__version__ = "0.1.0"

genropy_asgi/proxy/genropy_proxy.py

@@ -0,0 +1,102 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""GenropyProxyMixin — a GenroPy legacy db behind an OpenApiApplication.
+
+An ``OpenApiApplication`` mounts a RoutingClass and exposes it as REST (and, via
+``McpOpenApiApplication``, as MCP). When those handlers need the GenroPy legacy
+db, someone must own its lifecycle: the connection is thread-local and must be
+closed on the thread that opened it — the executor thread where the handler ran,
+not the loop. genro-asgi provides exactly that hook (``route_cleanup``, run in
+the executor thread by ``make_callable``); this mixin fills it.
+
+The mixin instantiates a ``GnrApp`` and exposes it as ``self.gnr_app`` (the only
+channel the mounted RoutingClass reads, e.g. through its parent). It overrides
+only what it owns — ``route_cleanup`` (close the current thread's connection) —
+and never the ``OpenApiApplication`` machinery. Direction of dependency is
+contrib -> genro-asgi: this imports ``gnr.*``; genro-asgi never imports GenroPy.
+
+Compose it with the base to get a mountable app::
+
+    class GenropyProxyOpenApiApplication(GenropyProxyMixin, OpenApiApplication):
+        ...
+
+NOTE (collaudo): this package currently lives in genro-asgi/contrib for
+end-to-end testing against the real GenroPy legacy. Once proven it will move to
+the genropy-asgi repository.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from genro_asgi.applications.openapi_application import OpenApiApplication
+
+log = logging.getLogger("genropy_asgi.proxy")
+
+__all__ = ["GenropyProxyMixin", "GenropyProxyOpenApiApplication"]
+
+
+class GenropyProxyMixin:
+    """Owns a ``GnrApp`` and closes its db connection in the executor thread.
+
+    Mixed before an ``OpenApiApplication``: it builds the GnrApp in ``on_init``
+    (before delegating to the base, which mounts the RoutingClass), exposes it as
+    ``gnr_app``, and fills ``route_cleanup`` to release the thread-local db
+    connection after each handler — where it is thread-correct.
+    """
+
+    def on_init(self, instance: str | None = None, debug: bool = False, **kwargs: Any) -> None:
+        """Build the GnrApp, then let the OpenApiApplication base mount the API.
+
+        Args:
+            instance: GenroPy instance name (or path) resolved by GnrApp.
+            debug: Passed through to GnrApp.
+            **kwargs: Forwarded to ``OpenApiApplication.on_init`` (routing_class,
+                module, docs, api_name, ...).
+        """
+        from gnr.app.gnrapp import GnrApp
+
+        if not instance:
+            raise ValueError("GenropyProxyMixin requires an 'instance'")
+        log.info("Creating GnrApp for instance '%s'", instance)
+        self._gnr_app = GnrApp(instance, debug=debug)
+        log.info("GnrApp '%s' ready", instance)
+        super().on_init(**kwargs)  # type: ignore[misc]
+
+    @property
+    def gnr_app(self) -> Any:
+        """The hosted GnrApp — the only channel the mounted RoutingClass reads."""
+        return self._gnr_app
+
+    def route_cleanup(self) -> None:
+        """Close the current thread's db connection after the handler.
+
+        Runs in the executor thread (via ``make_callable``), which is where the
+        GnrApp opened its thread-local connection, so this is where it must be
+        closed. The request-level cleanup runs on the loop and cannot do it.
+        """
+        db = getattr(self._gnr_app, "db", None)
+        if db is not None:
+            db.closeConnection()
+
+    def on_shutdown(self) -> None:
+        """Release the GnrApp on server stop, then the base."""
+        db = getattr(self._gnr_app, "db", None)
+        if db is not None:
+            db.closeConnection()
+        super().on_shutdown()  # type: ignore[misc]
+
+
+class GenropyProxyOpenApiApplication(GenropyProxyMixin, OpenApiApplication):
+    """OpenApiApplication hosting a GnrApp, mountable on an AsgiServer.
+
+    MRO: the mixin owns ``on_init``/``route_cleanup``/``on_shutdown``; the base
+    owns the REST + OpenAPI machinery. Mount it like any OpenApiApplication and
+    give it an ``instance`` plus a ``routing_class`` (or ``module``).
+    """
+
+
+if __name__ == "__main__":
+    pass

genropy_asgi/siteregister/__init__.py

@@ -0,0 +1,20 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""genropy_asgi.siteregister — the daemonless register the legacy imports.
+
+This subpackage is the provider of the ``gnr.web:daemon`` entry-point: the legacy
+``gnr.web.daemon`` switcher installs it as ``gnr.web.daemon`` in ``sys.modules``, so
+``from gnr.web.daemon.siteregister_client import SiteRegisterClient`` and the handful of
+other legacy imports resolve to the files here — with no register daemon behind them.
+
+The register is served entirely in-process by ``GenropyRegisterClient`` (the SPA
+application's own registries/surface/mailbox). The ``handler`` / ``service`` /
+``processes`` modules are fakes: they exist only so the ``gnr.web.daemon.*`` namespace
+resolves for the daemon-CLI / ``app.gnrdaemon`` paths (never reached in the request
+path), and raise if actually used — there is no daemon in this build.
+"""
+
+__all__ = ["SiteRegisterClient", "GenropyRegisterClient"]
+
+from .siteregister_client import GenropyRegisterClient, SiteRegisterClient

genropy_asgi/siteregister/exceptions.py

@@ -0,0 +1,36 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""Exceptions for the in-process siteregister.
+
+The names mirror the register-daemon hierarchy the legacy code catches (it does
+``except GnrDaemonLocked`` around a store lock). There is no daemon here, so
+``GnrDaemonLocked`` only ever fires on the in-process lock retry budget, and the
+transport errors (``GnrDaemonUnavailable``, ``GnrDaemonMethodNotFound``) can never
+happen — they are kept only so legacy imports and ``except`` clauses resolve.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "GnrDaemonException",
+    "GnrDaemonLocked",
+    "GnrDaemonMethodNotFound",
+    "GnrDaemonUnavailable",
+]
+
+
+class GnrDaemonException(Exception):
+    """Base class for register errors (kept for legacy compatibility)."""
+
+
+class GnrDaemonLocked(GnrDaemonException):
+    """An in-process item lock could not be acquired within the retry budget."""
+
+
+class GnrDaemonMethodNotFound(GnrDaemonException):
+    """Never raised in-process; kept so legacy imports resolve."""
+
+
+class GnrDaemonUnavailable(GnrDaemonException):
+    """Never raised in-process (no transport); kept for import compatibility."""

genropy_asgi/siteregister/handler.py

@@ -0,0 +1,28 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""Fake ``gnr.web.daemon.handler`` — there is no daemon in this build.
+
+The legacy lazily imports ``GnrDaemonProxy`` here only when something reads
+``app.gnrdaemon`` (a control/stop handle for the register daemon). Nothing in the
+request path does, so this is never reached in practice; it exists so the namespace
+resolves, and any actual use is an explicit error rather than a silent no-op.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["GnrDaemonProxy"]
+
+_NO_DAEMON = "no register daemon in this build (the register is served in-process)"
+
+
+class GnrDaemonProxy:
+    """Stub daemon-control proxy: constructing or calling it is an explicit error."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        raise RuntimeError(_NO_DAEMON)
+
+    def proxy(self) -> Any:
+        raise RuntimeError(_NO_DAEMON)

genropy_asgi/siteregister/processes.py

@@ -0,0 +1,12 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""Fake ``gnr.web.daemon.processes`` — the daemon service-process machinery is gone.
+
+No module outside the daemon package imported this at runtime; it exists only so the
+``gnr.web.daemon.processes`` namespace resolves for any stray import. Empty on purpose.
+"""
+
+from __future__ import annotations
+
+__all__: list[str] = []

genropy_asgi/siteregister/service.py

@@ -0,0 +1,28 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""Fake ``gnr.web.daemon.service`` — there is no daemon service in this build.
+
+The legacy CLI (``gnr web daemon``) imports ``DaemonService`` here. In the in-process
+build there is no daemon to start/stop, so running that command is an explicit error;
+the import itself resolves so the CLI dispatch table does not break at load time.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["DaemonService"]
+
+
+class DaemonService:
+    """Stub: there is no register daemon to control in the in-process build."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._args = args
+
+    def run(self) -> None:
+        raise RuntimeError(
+            "no register daemon in this build: the register is served in-process, "
+            "there is nothing to start with `gnr web daemon`"
+        )

genropy_asgi/siteregister/siteregister.py

@@ -0,0 +1,37 @@
+# Copyright 2025 Softwell S.r.l.
+# Licensed under the Apache License, Version 2.0
+
+"""The ``gnr.web.daemon.siteregister`` face of the in-process register.
+
+The legacy imports a handful of names from ``gnr.web.daemon.siteregister``
+(``DEFAULT_PAGE_MAX_AGE``, ``GnrDaemonException``) and its backward-compat shim
+re-exports ``RegisterResolver`` from here too. This module provides exactly those,
+with no daemon server behind them: the register lives inside the SPA application, not
+in a separate ``GnrSiteRegister`` process.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .exceptions import GnrDaemonException
+
+__all__ = ["DEFAULT_PAGE_MAX_AGE", "GnrDaemonException", "RegisterResolver"]
+
+# The page eviction window the legacy cleanup config falls back to (seconds).
+DEFAULT_PAGE_MAX_AGE = 120
+
+
+class RegisterResolver:
+    """Placeholder for the admin-UI lazy resolver (browse users/connections/pages).
+
+    The legacy re-exports this name; the in-process build does not drive the daemon
+    admin browser, so instantiating it is an explicit error rather than a silent
+    empty tree. Kept only so the import resolves.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        raise NotImplementedError(
+            "RegisterResolver (daemon admin browser) is not available in the "
+            "in-process siteregister"
+        )