encore-dev 2.0.0b6__tar.gz → 2.0.0b7__tar.gz

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: encore-dev
-Version: 2.0.0b6
+Version: 2.0.0b7
 Summary: Encore SDK for Python — infrastructure resources
 Author: Encore
 License: MPL-2.0

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/encore/_run.py

@@ -153,6 +153,7 @@ async def _lifecycle(http: Any) -> int:
 
 async def _shutdown(http: Any, force: asyncio.Event) -> int:
     from . import shutdown
+    from .internal.startup import stopped as subscriptions_stopped
 
     # Cooperative: Encore cleans up the resources the app uses once the app
     # says it is done (its requests answered, its lifespan shut down), or at
@@ -195,9 +196,17 @@ async def _shutdown(http: Any, force: asyncio.Event) -> int:
         await http.join(1.0)
 
     result = await shutdown.completed()
+    # Before the loop closes: the subscriptions' consumers ended as the
+    # shutdown began.
+    await subscriptions_stopped(_CONSUMERS_STOP)
     return result.code()
 
 
+#: How long the subscriptions' consumers may take to end once shutdown has
+#: completed.
+_CONSUMERS_STOP = 1.0
+
+
 #: How long after the first signal the same one again is a new one, not the
 #: first delivered twice.
 _REPEAT_SECS = 1.0

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/encore/internal/_native.pyi

@@ -734,7 +734,8 @@ class PubSubSubscription:
         """
         Consume messages on the calling asyncio loop until subscription shutdown.
         Handler completion acknowledges a message; exceptions propagate to the core
-        so the provider can apply its retry policy.
+        so the provider can apply its retry policy. Subscribing again moves the
+        handler to the calling loop: the subscription has one handler.
         """
 
 @final
@@ -1030,6 +1031,12 @@ class Runtime:
         """
         The version of the Encore runtime in use.
         """
+    def wait_completed(self, /) -> "ShutdownResult":
+        """
+        Wait for cleanup to finish, as `completed` does, blocking this thread
+        rather than awaiting: for the exit, which runs no event loop and
+        leaves the runtime nothing to complete. Call begin_shutdown first.
+        """
 
 @final
 class Secret:
@@ -1108,6 +1115,13 @@ def encode_log(level: int, time_unix_nanos: int, message: str, *, logger: str |N
     runtime.
     """
 
+def exiting(timeout: float) -> "None":
+    """
+    Says the interpreter is exiting: from now on the runtime's threads don't
+    enter Python. Waits up to `timeout` seconds for those in it to leave.
+    The last thing the SDK does at exit.
+    """
+
 def flush_runtime_log(timeout: float) -> "int":
     """
     Waits, up to `timeout` seconds, for the handler to take the lines queued

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/encore/internal/runtime.py

@@ -30,16 +30,24 @@ _native.set_runtime_log_handler(_handle_runtime_line)
 #: How long the runtime's queued lines may take to reach ``logging`` at exit.
 _RUNTIME_LOG_FLUSH = 1.0
 
+#: How long the runtime's threads in Python may take to leave it at exit.
+_LEAVE_PYTHON = 1.0
 
-def _flush_runtime_log() -> None:
-    """Hand the runtime's queued lines to ``logging`` before exit."""
+
+def _exit() -> None:
+    """Hand the runtime's queued lines to ``logging``, then leave Python be.
+
+    After this, the runtime's threads don't enter Python: one that did as
+    the interpreter finalizes could crash it.
+    """
     lost = _native.flush_runtime_log(_RUNTIME_LOG_FLUSH)
     if lost:
         print(f"encore: lost {lost} of the runtime's log lines", file=sys.stderr)
+    _native.exiting(_LEAVE_PYTHON)
 
 
 # Registered first, so it runs after the exit handlers registered later.
-atexit.register(_flush_runtime_log)
+atexit.register(_exit)
 
 # Instrumentations read this at import; Encore records stable semconv (ADR 0004).
 os.environ.setdefault("OTEL_SEMCONV_STABILITY_OPT_IN", "http")
@@ -62,28 +70,22 @@ def _shutdown() -> bool:
     global _shutdown_ok
     if _shutdown_ok is not None:
         return _shutdown_ok
-    import asyncio
-
-    from .. import shutdown
-
+    # Imports nothing, and runs no event loop: it runs at exit, and in the
+    # SIGTERM handler, which may interrupt an import.
     if threading.current_thread() is threading.main_thread():
         # A repeated SIGTERM must not interrupt the flush.
         signal.signal(signal.SIGTERM, signal.SIG_IGN)
-    shutdown.begin()
-    result: list[bool] = []
-
-    def wait() -> None:
-        try:
-            done = asyncio.run(shutdown.completed())
-            result.append(done is shutdown.ShutdownResult.SUCCESS)
-        except Exception as exc:  # noqa: BLE001
-            print(f"encore: shutdown failed: {exc}", file=sys.stderr)
-
-    # Off this thread, which may be running an event loop.
-    waiter = threading.Thread(target=wait, name="encore-shutdown")
-    waiter.start()
-    waiter.join()
-    _shutdown_ok = bool(result and result[0])
+    _runtime.begin_shutdown()
+    try:
+        result = _runtime.wait_completed()
+    except EncoreError as exc:
+        print(f"encore: shutdown failed: {exc}", file=sys.stderr)
+        result = None
+    if result == _native.ShutdownResult.Failed:
+        print(
+            "encore: shutdown failed: Encore resource cleanup failed", file=sys.stderr
+        )
+    _shutdown_ok = result == _native.ShutdownResult.Success
     return _shutdown_ok
 
 

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/encore/internal/startup.py

@@ -1,5 +1,7 @@
 """Application-loop startup for registered Encore resources."""
 
+import asyncio
+
 from .. import pubsub
 from .runtime import runtime
 
@@ -10,7 +12,9 @@ async def start() -> None:
     Start all registered subscriptions and return. Import resource declarations
     before calling this from your async main or framework startup hook.
     Repeated calls on the same loop reuse consumers; later calls also start newly
-    imported subscriptions. This does not own the loop or install signal handlers.
+    imported subscriptions. Once the loop they were started on has closed, as
+    a test client's does after each lifespan, a call on another moves them
+    there. This does not own the loop or install signal handlers.
 
     Shortly after, the runtime warns of each subscription the service hosts
     that has no handler, such as one declared in a module never imported.
@@ -28,3 +32,25 @@ async def start() -> None:
         subscription._start()
 
     runtime().subscriptions_started()
+
+
+async def stopped(timeout: float) -> None:
+    """Wait for this loop's subscription consumers to end, up to ``timeout``.
+
+    They end once Encore's shutdown begins, each resolved from a runtime
+    thread. Awaited before the loop closes, so their completions run on it,
+    and those still pending at ``timeout`` are cancelled.
+    """
+    loop = asyncio.get_running_loop()
+    consumers = {
+        consumer
+        for subscription in pubsub._subscriptions
+        if (consumer := subscription._consumer) is not None
+        and consumer.get_loop() is loop
+        and not consumer.done()
+    }
+    if not consumers:
+        return
+    _, pending = await asyncio.wait(consumers, timeout=timeout)
+    for consumer in pending:
+        consumer.cancel()

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/encore/pubsub/__init__.py

@@ -366,7 +366,7 @@ def _handler_context(message: _native.PubSubMessage) -> context_api.Context:
 
 
 class SubscriptionLoopError(RuntimeError):
-    """The subscription belongs to another asyncio loop."""
+    """The subscription runs on another asyncio loop, which is still open."""
 
 
 class Subscription(Generic[_T]):
@@ -375,6 +375,10 @@ class Subscription(Generic[_T]):
     Await encore.start() to begin consumption on the application's asyncio
     loop. The explicit type argument selects payload decoding; omitting it
     uses ordinary JSON decoding.
+
+    It runs on one loop at a time. Once that loop has closed, as a test
+    client's closes after its lifespan, encore.start() on another moves it
+    there.
     """
 
     def __init__(
@@ -446,14 +450,17 @@ class Subscription(Generic[_T]):
 
     def _check_loop(self) -> None:
         if self._consumer is not None:
-            if self._consumer.get_loop() is not asyncio.get_running_loop():
+            loop = self._consumer.get_loop()
+            if loop is not asyncio.get_running_loop() and not loop.is_closed():
                 raise SubscriptionLoopError(
                     "subscription already started on a different asyncio loop"
                 )
 
     def _start(self) -> asyncio.Future[None]:
         self._check_loop()
-        if self._consumer is None:
+        # Started anew where the loop it ran on has closed: the native
+        # subscription moves its handler to this one.
+        if self._consumer is None or self._consumer.get_loop().is_closed():
             self._consumer = asyncio.ensure_future(self._handle.get().subscribe())
             self._consumer.add_done_callback(self._consumer_done)
         return self._consumer

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "encore-dev"
-version = "2.0.0b6"
+version = "2.0.0b7"
 description = "Encore SDK for Python — infrastructure resources"
 readme = "README.md"
 requires-python = ">=3.9"

{encore_dev-2.0.0b6 → encore_dev-2.0.0b7}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "encore-dev"
-version = "2.0.0b6"
+version = "2.0.0b7"
 description = "Encore SDK for Python — infrastructure resources"
 readme = "README.md"
 requires-python = ">=3.9"