interlaced 2.8.6__tar.gz → 2.8.7__tar.gz

{interlaced-2.8.6/src/interlaced.egg-info → interlaced-2.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.8.6
+Version: 2.8.7
 Summary: Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres.
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT

{interlaced-2.8.6 → interlaced-2.8.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.8.6"
+version = "2.8.7"
 description = "Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres."
 readme = "README.md"
 requires-python = ">=3.12"

{interlaced-2.8.6 → interlaced-2.8.7}/src/interlace/cli/operate.py

@@ -288,7 +288,7 @@ def serve(
     apply_on_start: bool = typer.Option(
         True,
         "--apply/--no-apply",
-        help="Apply the project once at startup. --no-apply serves the warehouse as it is.",
+        help="Apply once at startup, while the API is already listening. --no-apply serves the warehouse as it is.",
     ),
     allow_open: bool = typer.Option(
         False,
@@ -299,7 +299,8 @@ def serve(
     """Run the interlace daemon: HTTP API + scheduler in one process (requires the `service` extra).
 
     Use --no-scheduler for an API-only process (run `interlace scheduler` separately).
-    The project is applied once before the loops start; pass --no-apply to skip that.
+    The API listens immediately. The project is applied once at startup, before the
+    scheduler loop; pass --no-apply to skip that. Writes return 503 until the apply finishes.
     A `cdc:` block in the project config is read here: each Postgres slot appends into its stream.
     """
     try:

{interlaced-2.8.6 → interlaced-2.8.7}/src/interlace/service/app.py

@@ -19,7 +19,7 @@ from litestar.static_files import create_static_files_router
 from interlace import __version__
 from interlace.exceptions import BreakingPlanError, LockError
 from interlace.service.auth import auth_guard
-from interlace.service.lifespan import project_lifespan
+from interlace.service.lifespan import project_lifespan, startup_guard
 from interlace.service.routes.admin import (
     delete_apikey,
     get_apikeys,
@@ -90,7 +90,8 @@ def create_app(
     ``scheduler=True`` makes this the combined daemon: the HTTP API plus a
     background scheduler loop (tick triggers, drain the run queue) in one
     process — the default for ``interlace serve``. ``apply_on_start`` applies the
-    project once before the loops start; the ``serve`` command turns it on.
+    project once while the API is already accepting connections; writes get
+    503 until that apply finishes. The ``serve`` command turns it on.
     ``quack`` (a
     ``quack:<host>:<port>`` URI) additionally serves the warehouse over the
     quack protocol so other processes — CLI runs, ad-hoc DuckDB clients —
@@ -220,7 +221,7 @@ def create_app(
             stream_events,
         ],
         lifespan=[lifespan],
-        guards=[auth_guard],
+        guards=[auth_guard, startup_guard],
         openapi_config=OpenAPIConfig(
             title="interlace",
             version=__version__,

{interlaced-2.8.6 → interlaced-2.8.7}/src/interlace/service/lifespan.py

@@ -17,7 +17,9 @@ from pathlib import Path
 from typing import cast
 
 from litestar import Litestar
-from litestar.exceptions import ImproperlyConfiguredException
+from litestar.connection import ASGIConnection
+from litestar.exceptions import ImproperlyConfiguredException, ServiceUnavailableException
+from litestar.handlers.base import BaseRouteHandler
 
 from interlace.graph.column_lineage import column_lineage
 from interlace.project import Project
@@ -38,6 +40,21 @@ from interlace.streaming.materializer import (
 )
 
 
+async def startup_guard(connection: ASGIConnection, _route_handler: BaseRouteHandler) -> None:
+    """Refuse writes until the startup apply has finished.
+
+    The socket is open while that apply runs, so a client gets this response
+    instead of a refused connection. Reads stay available.
+    """
+    status = getattr(connection.app.state, "startup_status", "ok")
+    if status == "ok" or connection.scope.get("method", "GET") in ("GET", "HEAD", "OPTIONS"):
+        return
+    if status == "starting":
+        raise ServiceUnavailableException(detail="startup apply is still running")
+    detail = getattr(connection.app.state, "startup_error", "") or "startup apply failed"
+    raise ServiceUnavailableException(detail=detail)
+
+
 def project_lifespan(  # noqa: C901
     root: Path | str,
     environment: str,
@@ -140,6 +157,10 @@ def project_lifespan(  # noqa: C901
 
         if streams:
             app.state.flush_wanted.set()  # catch up anything durable but unflushed at last shutdown
+        # "starting" until the first apply finishes. The socket opens at the yield
+        # below, so clients reach /health instead of a refused connection.
+        app.state.startup_status = "starting" if apply_on_start else "ok"
+        app.state.startup_error = ""
 
         async def shutdown_watch() -> None:
             """End every open SSE stream the moment uvicorn begins shutting down.
@@ -159,16 +180,36 @@ def project_lifespan(  # noqa: C901
                 with contextlib.suppress(asyncio.QueueFull):
                     subscriber.put_nowait(None)
 
-        if apply_on_start:
-            await startup_apply(app.state)
+        flusher_task: asyncio.Task[None] | None = None
+        loop_task: asyncio.Task[None] | None = None
+        cdc_task: asyncio.Task[None] | None = None
+
+        async def open_service() -> None:
+            """Apply first, then the loops. The listen socket is already open."""
+            nonlocal flusher_task, loop_task, cdc_task
+            try:
+                if apply_on_start:
+                    logger.info("startup apply running; the API is accepting connections")
+                    await startup_apply(app.state)
+                app.state.startup_status = "ok"
+            except Exception as exc:
+                app.state.startup_status = "error"
+                app.state.startup_error = str(exc)
+                logger.exception("startup apply failed")
+                server = getattr(app.state, "uvicorn_server", None)
+                if server is not None:
+                    server.should_exit = True
+                return
+            if streams:
+                flusher_task = asyncio.create_task(flusher_loop(app.state, flush_interval=stream_flush_interval))
+            if scheduler:
+                loop_task = asyncio.create_task(scheduler_loop(app.state, interval=scheduler_interval))
+            if project.config.cdc:
+                cdc_task = asyncio.create_task(cdc_loop(app.state))
 
         tail_task = asyncio.create_task(event_tail())
-        flusher_task = (
-            asyncio.create_task(flusher_loop(app.state, flush_interval=stream_flush_interval)) if streams else None
-        )
-        loop_task = asyncio.create_task(scheduler_loop(app.state, interval=scheduler_interval)) if scheduler else None
-        cdc_task = asyncio.create_task(cdc_loop(app.state)) if project.config.cdc else None
         watch_task = asyncio.create_task(shutdown_watch())
+        service_task = asyncio.create_task(open_service())
         try:
             yield
         finally:
@@ -183,6 +224,10 @@ def project_lifespan(  # noqa: C901
             for subscriber in list(app.state.sse_subscribers):
                 with contextlib.suppress(asyncio.QueueFull):
                     subscriber.put_nowait(None)
+            # Stop the opener first so it cannot start a loop after this snapshot.
+            service_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await service_task
             for task in (cdc_task, loop_task, flusher_task, tail_task, watch_task):
                 if task is not None:
                     task.cancel()

{interlaced-2.8.6 → interlaced-2.8.7}/src/interlace/service/routes/models.py

@@ -33,7 +33,13 @@ from interlace.service.types import (
 
 @get("/health")
 async def health(state: State) -> dict[str, str]:
-    return {"status": "ok", "version": __version__, "environment": state.environment}
+    status = getattr(state, "startup_status", "ok")
+    body = {"status": status, "version": __version__, "environment": state.environment}
+    if status == "starting":
+        body["detail"] = "startup apply is still running"
+    elif status == "error":
+        body["detail"] = getattr(state, "startup_error", "") or "startup apply failed"
+    return body
 
 
 @get("/", include_in_schema=False)

{interlaced-2.8.6 → interlaced-2.8.7/src/interlaced.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.8.6
+Version: 2.8.7
 Summary: Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres.
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT