interlaced 2.2.0__tar.gz → 2.3.0__tar.gz

{interlaced-2.2.0/src/interlaced.egg-info → interlaced-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.2.0
+Version: 2.3.0
 Summary: Python/SQL-first data platform: transformation, built-in orchestration, and durable streaming ingestion
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT
@@ -18,12 +18,12 @@ Classifier: Programming Language :: SQL
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlglot<29.0,>=25.0
+Requires-Dist: sqlglot<30.0,>=25.0
 Requires-Dist: duckdb>=1.5.3
 Requires-Dist: pyarrow>=17.0
 Requires-Dist: pydantic<3.0,>=2.5
 Requires-Dist: typer<1.0,>=0.12
-Requires-Dist: rich<15.0,>=13.0
+Requires-Dist: rich<16.0,>=13.0
 Requires-Dist: cronsim<3.0,>=2.5
 Requires-Dist: tenacity<10.0,>=8.2
 Requires-Dist: pyyaml<7.0,>=6.0
@@ -59,7 +59,7 @@ Requires-Dist: httpx<1.0,>=0.27; extra == "dev"
 Requires-Dist: pytest-asyncio<2.0,>=1.0; extra == "dev"
 Requires-Dist: ruff<1.0,>=0.6; extra == "dev"
 Requires-Dist: black<27.0,>=24.0; extra == "dev"
-Requires-Dist: mypy<2.0,>=1.11; extra == "dev"
+Requires-Dist: mypy<3.0,>=1.11; extra == "dev"
 Dynamic: license-file
 
 # interlace
@@ -127,8 +127,9 @@ def orders(cursor, this):
 ```
 
 **Strategies:** `replace`, `view`, `ephemeral` (CTE-inlined), `merge` (upsert),
-`full_merge` (full-state source applied as a minimal diff), `incremental_by_time`
-(windowed, interval-ledger backfill/catchup), `scd` (history with validity windows).
+`full_merge` (full-state source applied as a minimal diff), `incremental` (one time window
+at a time — rewrites the window, or upserts within it if you give it a `key`), `scd`
+(history with validity windows).
 
 ## Plan / apply
 

{interlaced-2.2.0 → interlaced-2.3.0}/README.md

@@ -63,8 +63,9 @@ def orders(cursor, this):
 ```
 
 **Strategies:** `replace`, `view`, `ephemeral` (CTE-inlined), `merge` (upsert),
-`full_merge` (full-state source applied as a minimal diff), `incremental_by_time`
-(windowed, interval-ledger backfill/catchup), `scd` (history with validity windows).
+`full_merge` (full-state source applied as a minimal diff), `incremental` (one time window
+at a time — rewrites the window, or upserts within it if you give it a `key`), `scd`
+(history with validity windows).
 
 ## Plan / apply
 

{interlaced-2.2.0 → interlaced-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.2.0"
+version = "2.3.0"
 description = "Python/SQL-first data platform: transformation, built-in orchestration, and durable streaming ingestion"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -24,12 +24,12 @@ classifiers = [
 # Core: the IR + engine + state + plan spine (Phase 1). Everything is Arrow- and
 # sqlglot-native. See docs/architecture/architecture.md.
 dependencies = [
-    "sqlglot>=25.0,<29.0",        # canonical IR, transpilation, semantic diff, column lineage
+    "sqlglot>=25.0,<30.0",        # canonical IR, transpilation, semantic diff, column lineage
     "duckdb>=1.5.3",              # default engine + federation hub; DuckLake storage + quack serving
     "pyarrow>=17.0",              # the wire format: RecordBatchReader everywhere
     "pydantic>=2.5,<3.0",         # config + manifest validation (cold paths only)
     "typer>=0.12,<1.0",           # CLI
-    "rich>=13.0,<15.0",           # display, strictly an event subscriber
+    "rich>=13.0,<16.0",           # display, strictly an event subscriber
     "cronsim>=2.5,<3.0",          # cron parsing for the trigger engine
     "tenacity>=8.2,<10.0",        # retries (tasks, DuckLake commit conflicts, transfers)
     "pyyaml>=6.0,<7.0",           # project config (config + env overlays)
@@ -78,7 +78,7 @@ dev = [
     "pytest-asyncio>=1.0,<2.0",
     "ruff>=0.6,<1.0",
     "black>=24.0,<27.0",
-    "mypy>=1.11,<2.0",
+    "mypy>=1.11,<3.0",
 ]
 
 [tool.setuptools.packages.find]

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/cli/main.py

@@ -107,7 +107,7 @@ _END = typer.Option("", "--end", help="Window end (ISO), for incremental models.
 _FORWARD_ONLY = typer.Option(
     False,
     "--forward-only",
-    help="Modified history-keeping models (merge/full_merge/scd/incremental_by_time) carry their history "
+    help="Modified history-keeping models (merge/full_merge/scd/incremental) carry their history "
     "forward: it is copied to the new version, the new logic applies to the copy, and checks gate "
     "before views move. Requires a shape-compatible change.",
 )
@@ -205,7 +205,7 @@ async def _render_empty_incrementals(result: ApplyResult, compiled: CompiledProj
 
     for name in result.built:
         model = compiled.models[name]
-        if model.strategy != "incremental_by_time" or model.is_terminal:
+        if model.strategy != "incremental" or model.is_terminal:
             continue
         counts = result.rows.get(name)
         if counts is not None and (counts.inserted or counts.updated):
@@ -404,7 +404,7 @@ def run(
 ) -> None:
     """Force-build models and promote, ignoring change detection.
 
-    For incremental_by_time models, --start/--end set the catchup window
+    For incremental models, --start/--end set the catchup window
     (default: the latest grain interval).
     """
     asyncio.run(_execute(environment, path, select, start, end, restate=False, parallelism=parallelism))

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/dsl/decorators.py

@@ -94,9 +94,9 @@ class ModelDef:
     dialect: str | None = None
     engine: str | None = None  # named engine from config (None → project default_engine)
     depends_on: tuple[str, ...] = ()
-    interval: str | None = None  # grain for incremental_by_time (e.g. "1d")
-    time_column: str | None = None  # partition column for incremental_by_time
-    # First-build window for incremental_by_time: "auto" derives [min, max] of the
+    interval: str | None = None  # grain for incremental (e.g. "1d")
+    time_column: str | None = None  # partition column for incremental
+    # First-build window for incremental: "auto" derives [min, max] of the
     # time column from the source at apply time and fills it as ONE interval;
     # "none" keeps only the latest grain window; an ISO date pins the start.
     backfill: str = "auto"

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/dsl/discovery.py

@@ -64,7 +64,7 @@ def _sql_model(default_name: str, sql: str, config: dict[str, Any], default_dial
         depends_on=_as_tuple(config.get("depends_on") or ()),
         interval=config.get("interval"),
         time_column=config.get("time_column"),
-        backfill=config.get("backfill", "auto"),  # first-build window for incremental_by_time
+        backfill=config.get("backfill", "auto"),  # first-build window for incremental
         tags=_as_tuple(config.get("tags") or ()),
         owner=config.get("owner"),
         description=config.get("description"),

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/engines/spark.py

@@ -7,7 +7,7 @@ come back as Arrow via ``DataFrame.toArrow()``, and Arrow loads go in through
 (``local[*]``, for tests) or a remote one (Spark Connect / a shared session).
 
 **Strategy support.** ``replace``, ``append`` and ``view`` run on any Spark
-catalog. ``merge`` (native ``MERGE``) and ``incremental_by_time`` (windowed
+catalog. ``merge`` (native ``MERGE``) and ``incremental`` (windowed
 ``DELETE`` by literal predicate + ``INSERT``) need a catalog with row-level
 mutations — Delta Lake or Iceberg — configured on the session you hand the
 adapter (the tests use a Delta-backed local session). ``scd`` and ``full_merge``

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/graph/project.py

@@ -44,9 +44,9 @@ class CompiledModel:
     materialise: str
     strategy: str
     key: tuple[str, ...]  # business key for keyed strategies (merge)
-    time_column: str | None  # partition column for incremental_by_time
+    time_column: str | None  # partition column for incremental
     cursor: str | None  # column whose max is injected into a Python model's `cursor` param
-    interval: str | None  # grain for incremental_by_time (e.g. "1d")
+    interval: str | None  # grain for incremental (e.g. "1d")
     tags: tuple[str, ...]  # for tag: selection
     schedule: dict[str, str] | None  # cron/interval schedule for the trigger engine
     columns: dict[str, str | None] | None  # output contract validated at apply time

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/ir/canonicalize.py

@@ -8,6 +8,8 @@ pruning and the ``impact`` command).
 
 from __future__ import annotations
 
+from typing import cast
+
 import sqlglot
 from sqlglot import exp
 
@@ -86,4 +88,5 @@ def resolve_references(ast: exp.Expression, mapping: dict[str, TableRef]) -> exp
                 node.set("catalog", exp.to_identifier(target.catalog) if target.catalog else None)
         return node
 
-    return ast.transform(rewrite)
+    # sqlglot 29 loosened transform()'s return annotation; it is an Expression.
+    return cast("exp.Expression", ast.transform(rewrite))

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/plan/apply.py

@@ -36,7 +36,7 @@ from interlace.runtime.python_model import build_python_model, run_python_model
 from interlace.sinks import file_statements, target_ref
 from interlace.state.interval import Interval
 from interlace.state.store import StateStore
-from interlace.strategies import Strategy, resolve_strategy
+from interlace.strategies import Incremental, Strategy, resolve_strategy
 from interlace.strategies.base import RowCounts
 from interlace.strategies.hash_merge import HashMerge
 
@@ -87,7 +87,9 @@ async def _merge_python_output(
     reader: pa.RecordBatchReader,
     *,
     exists: bool,
-) -> RowCounts:
+    interval: Interval | None = None,
+    bootstrap: bool = False,
+) -> tuple[RowCounts, Interval | None]:
     """Stage a Python model's Arrow output and apply its keyed strategy in SQL.
 
     The output lands in a stage table (CREATE OR REPLACE, so a crashed run's
@@ -114,10 +116,15 @@ async def _merge_python_output(
         columns = [c for c in await engine.describe(stage) if c not in strategy.managed_columns]
 
     relation = SqlRelation(ast=source)
-    statements = strategy.plan_statements(relation, target, engine.caps, None, columns)
+    if isinstance(strategy, Incremental) and bootstrap:
+        # First build of a keyed incremental Python model: the range comes from the
+        # staged output, since there is no query to probe the way a SQL model has.
+        interval = await _bootstrap_window(model, exp.select("*").from_(stage_table.copy()), engine)
+    statements = strategy.plan_statements(relation, target, engine.caps, interval, columns)
     drop_stage = exp.Drop(this=stage_table.copy(), kind="TABLE", exists=True)
     counts = await engine.execute_all([*pre_statements, *statements, drop_stage])
-    return strategy.row_counts(counts[len(pre_statements) : len(pre_statements) + len(statements)])
+    written = strategy.row_counts(counts[len(pre_statements) : len(pre_statements) + len(statements)])
+    return written, interval
 
 
 async def _align_stage_to_target(
@@ -183,7 +190,7 @@ async def _deliver_table(
     interval: Interval | None,
 ) -> RowCounts:
     """Deliver ``resolved`` into an external table (``materialise: table``) via
-    ``strategy`` (replace / append / merge / full_merge / incremental_by_time).
+    ``strategy`` (replace / append / merge / full_merge / incremental).
 
     The external target is never dropped (grants and readers survive). When it already
     exists the source is staged in the warehouse and aligned to the target (additive
@@ -193,7 +200,7 @@ async def _deliver_table(
     order exactly.
 
     Two cases skip staging and run the strategy directly against the target: the first
-    delivery (the ensure-create matches the source), and any windowed ``incremental_by_time``
+    delivery (the ensure-create matches the source), and any windowed ``incremental``
     delivery (``interval`` set). An incremental window is grain-scoped and stays
     schema-stable within a fingerprint, so staging the *whole* source once per window
     would make a wide backfill/restate O(windows × source) — the pathological case."""
@@ -435,9 +442,17 @@ async def _run_backfill(
                 f"Python model {snapshot.name!r} must materialise as virtual; table/file (write a SQL model "
                 f"over its output), view and ephemeral are not supported for Python models"
             )
-        if model.strategy == "incremental_by_time":
+        if model.strategy == "incremental" and not model.key:
+            # Keyed is supported: the window bounds which staged rows are upserted.
+            # Unkeyed is not, and deliberately. For a SQL model the window predicate
+            # is pushed into the query so the engine only computes the window; a
+            # Python function has already computed everything by the time we could
+            # filter it, so an unkeyed windowed rewrite would look incremental while
+            # doing the full work every run. Bound the fetch with cursor= instead.
             raise PlanError(
-                f"Python model {snapshot.name!r} cannot use incremental_by_time; " f"use cursor= with merge instead"
+                f"Python model {snapshot.name!r} cannot use incremental without a key: the function "
+                f"runs in full before the window can be applied, so the window would not save any work. "
+                f"Add key= to upsert the window's rows, or use cursor= with merge to bound the fetch"
             )
         recorded_self = await state.get_snapshot(snapshot.name, snapshot.fingerprint)
         previous = recorded_self.physical_table if recorded_self is not None else None
@@ -452,10 +467,21 @@ async def _run_backfill(
             result.record_rows(snapshot.name, RowCounts(inserted=loaded))
         else:  # keyed strategy: stage the Arrow output, then merge it in SQL
             reader = await run_python_model(model, compiled, target_engine, resolution, previous)
-            merged = await _merge_python_output(
-                model, target_engine, snapshot.physical_table, reader, exists=previous is not None
+            merged, filled_window = await _merge_python_output(
+                model,
+                target_engine,
+                snapshot.physical_table,
+                reader,
+                exists=previous is not None,
+                interval=task.interval,
+                bootstrap=task.bootstrap,
             )
             result.record_rows(snapshot.name, merged)
+            if filled_window is not None:  # incremental: accumulate the window in the ledger
+                filled = await state.get_intervals(snapshot.name, snapshot.fingerprint)
+                for carried in snapshot.intervals:
+                    filled = filled.add(carried)
+                snapshot = replace(snapshot, intervals=filled.add(filled_window))
         if model.columns:
             validate_contract(model.name, await target_engine.describe(snapshot.physical_table), model.columns)
         await state.add_snapshot(snapshot)

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/plan/differ.py

@@ -243,7 +243,7 @@ def _schedule_reuse(plan: Plan, model: CompiledModel, previous: Snapshot, enviro
         )
 
 
-_HISTORY_STRATEGIES = frozenset({"merge", "full_merge", "hash_merge", "scd", "incremental_by_time"})
+_HISTORY_STRATEGIES = frozenset({"merge", "full_merge", "hash_merge", "scd", "incremental"})
 """Strategies whose targets accumulate state a rebuild would destroy."""
 
 
@@ -283,7 +283,7 @@ async def diff(
     classification still runs over the whole graph so downstream categories are correct.
 
     ``forward_only``: modified models whose strategy accumulates history
-    (merge / full_merge / scd / incremental_by_time) inherit their
+    (merge / full_merge / scd / incremental) inherit their
     previous physical table and interval ledger instead of starting fresh — the
     new logic applies going forward, history survives. Requires the new query to
     stay shape-compatible with the existing table.

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/plan/plan.py

@@ -137,7 +137,7 @@ def schedule_build(
     table/file builds (delivers) but gets no environment view; a virtual/view model
     builds and is repointed by an environment view.
 
-    An incremental_by_time model (virtual, or a terminal ``table``) cannot build
+    An incremental model (virtual, or a terminal ``table``) cannot build
     without a window, so an apply fills the latest grain interval — the same default
     as ``interlace run`` — leaving history to ``run --start/--end``.
 
@@ -160,7 +160,7 @@ def schedule_build(
                 ViewSwap(env_view(environment, model.name), snapshot.physical_table, engine=model.engine)
             )
 
-    if model.strategy == "incremental_by_time":  # virtual or terminal table: windowed delete+insert
+    if model.strategy == "incremental":  # virtual or terminal table: windowed delete+insert
         from datetime import datetime
 
         from interlace.state.interval import latest_complete_window, parse_grain

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/plan/run.py

@@ -70,7 +70,7 @@ async def run_plan(
 
         # incremental into the interlace-owned virtual plane, or into a terminal
         # `table` (windowed delete+insert against the external target)
-        is_incremental = model.strategy == "incremental_by_time" and model.materialise != "ephemeral"
+        is_incremental = model.strategy == "incremental" and model.materialise != "ephemeral"
         wants_view = model.materialise in ("virtual", "view")  # terminal table has no env view
         if is_incremental:
             grain = parse_grain(model.interval or "1d")

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/service/app.py

@@ -1618,10 +1618,14 @@ def create_app(
 
             async def send_wrapper(message: Message) -> None:
                 if message["type"] == "http.response.start":
-                    headers = message.setdefault("headers", [])
-                    headers.append((b"content-security-policy", ui_csp.encode()))
-                    headers.append((b"x-content-type-options", b"nosniff"))
-                    headers.append((b"x-frame-options", b"DENY"))
+                    # ASGI types `headers` as an Iterable, not a list, so copy into one
+                    # rather than appending to whatever the server happened to pass.
+                    message["headers"] = [
+                        *message.get("headers", []),
+                        (b"content-security-policy", ui_csp.encode()),
+                        (b"x-content-type-options", b"nosniff"),
+                        (b"x-frame-options", b"DENY"),
+                    ]
                 await send(message)
 
             await app(scope, receive, send_wrapper)

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlace/strategies/__init__.py

@@ -9,7 +9,7 @@ from interlace.strategies.append import Append
 from interlace.strategies.base import Strategy, table_expr
 from interlace.strategies.full_merge import FullMerge
 from interlace.strategies.hash_merge import HashMerge
-from interlace.strategies.incremental_by_time import IncrementalByTime
+from interlace.strategies.incremental import Incremental
 from interlace.strategies.merge import Merge
 from interlace.strategies.replace import Replace
 from interlace.strategies.replace_in_place import ReplaceInPlace
@@ -20,7 +20,7 @@ __all__ = [
     "Append",
     "FullMerge",
     "HashMerge",
-    "IncrementalByTime",
+    "Incremental",
     "Merge",
     "Replace",
     "ReplaceInPlace",
@@ -72,9 +72,15 @@ def resolve_strategy(
                 raise PlanError("hash_merge requires a key", details={"materialise": materialise})
             return HashMerge(tuple(key))
         if strategy == "incremental_by_time":
+            raise PlanError(
+                "strategy: incremental_by_time was renamed to incremental — the behaviour is unchanged, "
+                "and `key:` now additionally makes it upsert within the window instead of rewriting it",
+                details={"materialise": materialise, "strategy": strategy},
+            )
+        if strategy == "incremental":
             if not time_column:
-                raise PlanError("incremental_by_time requires a time_column", details={"materialise": materialise})
-            return IncrementalByTime(time_column)
+                raise PlanError("incremental requires a time_column", details={"materialise": materialise})
+            return Incremental(time_column, tuple(key))
         if strategy == "scd":
             if not key:
                 raise PlanError("scd requires a key", details={"materialise": materialise})

interlaced-2.3.0/src/interlace/strategies/incremental.py

@@ -0,0 +1,89 @@
+"""Incremental strategy — one time window at a time.
+
+Both modes read only the rows whose ``time_column`` falls in the window
+``[start, end)`` the scheduler/planner supplies. They differ in what the window
+means for the target:
+
+- **without ``key`` (the default)** — the window is *authoritative*. Delete
+  everything already in ``[start, end)``, then insert the window's rows. A row
+  that vanished from the source disappears from the target. Delete-then-reinsert
+  is what makes reprocessing a window idempotent, and therefore what makes
+  backfill and ``restate`` safe.
+
+- **with ``key``** — the window only *bounds what is read*. Rows are upserted by
+  key, so a target row inside the window that the source no longer produces is
+  left alone. This is the mode for late-arriving corrections to rows you have
+  already published, where the window is a cheap way to avoid rescanning history
+  rather than a statement about what the period should contain.
+
+The grain (``interval`` config) lives with the planner, not here.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import cast
+
+from sqlglot import exp
+
+from interlace.engines.base import EngineCaps
+from interlace.exceptions import PlanError
+from interlace.ir.relation import SqlRelation, TableRef
+from interlace.state.interval import Interval
+from interlace.strategies.base import RowCounts, Strategy, _at, table_expr
+from interlace.strategies.merge import Merge
+
+
+class Incremental(Strategy):
+    """``DELETE`` the window + ``INSERT`` it, or — with a ``key`` — upsert within it."""
+
+    def __init__(self, time_column: str, key: tuple[str, ...] = ()) -> None:
+        if not time_column:
+            raise PlanError("incremental requires a time_column")
+        self.time_column = time_column
+        self.key = key
+        # Keyed mode is a merge whose source happens to be window-filtered, so the
+        # upsert itself (native MERGE, or the portable DELETE+INSERT fallback) is
+        # the one in Merge rather than a second copy of it here.
+        self._merge = Merge(key) if key else None
+
+    def plan_statements(
+        self,
+        relation: SqlRelation,
+        target: TableRef,
+        caps: EngineCaps,
+        interval: Interval | None = None,
+        columns: Sequence[str] | None = None,
+    ) -> list[exp.Expression]:
+        if interval is None:
+            raise PlanError("incremental requires an interval to process")
+        query = relation.ast
+        table = table_expr(target)
+
+        def derived() -> exp.Subquery:
+            return cast("exp.Query", query.copy()).subquery("_s")
+
+        def window() -> exp.Expression:
+            column = exp.column(self.time_column)
+            return exp.And(
+                this=exp.GTE(this=column.copy(), expression=exp.Literal.string(interval.start.isoformat())),
+                expression=exp.LT(this=column.copy(), expression=exp.Literal.string(interval.end.isoformat())),
+            )
+
+        if self._merge is not None:
+            # The window bounds the source; the key decides what is written.
+            windowed = exp.select("*").from_(derived()).where(window())
+            return self._merge.plan_statements(SqlRelation(ast=windowed), target, caps, interval, columns)
+
+        ensure = exp.Create(
+            this=table.copy(), kind="TABLE", exists=True, expression=exp.select("*").from_(derived()).limit(0)
+        )
+        delete = exp.Delete(this=table.copy(), where=exp.Where(this=window()))
+        insert = exp.Insert(this=table.copy(), expression=exp.select("*").from_(derived()).where(window()))
+        return [ensure, delete, insert]
+
+    def row_counts(self, counts: Sequence[int]) -> RowCounts:
+        if self._merge is not None:
+            return self._merge.row_counts(counts)
+        # [ensure, delete window, insert window]: catchup deletes 0; restate rewrites
+        return RowCounts(inserted=_at(counts, 2), deleted=_at(counts, 1))

{interlaced-2.2.0 → interlaced-2.3.0/src/interlaced.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.2.0
+Version: 2.3.0
 Summary: Python/SQL-first data platform: transformation, built-in orchestration, and durable streaming ingestion
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT
@@ -18,12 +18,12 @@ Classifier: Programming Language :: SQL
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlglot<29.0,>=25.0
+Requires-Dist: sqlglot<30.0,>=25.0
 Requires-Dist: duckdb>=1.5.3
 Requires-Dist: pyarrow>=17.0
 Requires-Dist: pydantic<3.0,>=2.5
 Requires-Dist: typer<1.0,>=0.12
-Requires-Dist: rich<15.0,>=13.0
+Requires-Dist: rich<16.0,>=13.0
 Requires-Dist: cronsim<3.0,>=2.5
 Requires-Dist: tenacity<10.0,>=8.2
 Requires-Dist: pyyaml<7.0,>=6.0
@@ -59,7 +59,7 @@ Requires-Dist: httpx<1.0,>=0.27; extra == "dev"
 Requires-Dist: pytest-asyncio<2.0,>=1.0; extra == "dev"
 Requires-Dist: ruff<1.0,>=0.6; extra == "dev"
 Requires-Dist: black<27.0,>=24.0; extra == "dev"
-Requires-Dist: mypy<2.0,>=1.11; extra == "dev"
+Requires-Dist: mypy<3.0,>=1.11; extra == "dev"
 Dynamic: license-file
 
 # interlace
@@ -127,8 +127,9 @@ def orders(cursor, this):
 ```
 
 **Strategies:** `replace`, `view`, `ephemeral` (CTE-inlined), `merge` (upsert),
-`full_merge` (full-state source applied as a minimal diff), `incremental_by_time`
-(windowed, interval-ledger backfill/catchup), `scd` (history with validity windows).
+`full_merge` (full-state source applied as a minimal diff), `incremental` (one time window
+at a time — rewrites the window, or upserts within it if you give it a `key`), `scd`
+(history with validity windows).
 
 ## Plan / apply
 

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlaced.egg-info/SOURCES.txt

@@ -89,7 +89,7 @@ src/interlace/strategies/append.py
 src/interlace/strategies/base.py
 src/interlace/strategies/full_merge.py
 src/interlace/strategies/hash_merge.py
-src/interlace/strategies/incremental_by_time.py
+src/interlace/strategies/incremental.py
 src/interlace/strategies/merge.py
 src/interlace/strategies/replace.py
 src/interlace/strategies/replace_in_place.py

{interlaced-2.2.0 → interlaced-2.3.0}/src/interlaced.egg-info/requires.txt

@@ -1,9 +1,9 @@
-sqlglot<29.0,>=25.0
+sqlglot<30.0,>=25.0
 duckdb>=1.5.3
 pyarrow>=17.0
 pydantic<3.0,>=2.5
 typer<1.0,>=0.12
-rich<15.0,>=13.0
+rich<16.0,>=13.0
 cronsim<3.0,>=2.5
 tenacity<10.0,>=8.2
 pyyaml<7.0,>=6.0
@@ -29,7 +29,7 @@ httpx<1.0,>=0.27
 pytest-asyncio<2.0,>=1.0
 ruff<1.0,>=0.6
 black<27.0,>=24.0
-mypy<2.0,>=1.11
+mypy<3.0,>=1.11
 
 [pandas]
 pandas<4.0,>=2.0

interlaced-2.2.0/src/interlace/strategies/incremental_by_time.py

@@ -1,64 +0,0 @@
-"""Incremental-by-time strategy.
-
-Processes one time window ``[start, end)`` at a time: ensure the target exists,
-delete that window, then insert the query filtered to it. Re-processing a window
-is idempotent (delete + reinsert), which is what makes backfill and catchup safe.
-The concrete interval comes from the scheduler/planner; the grain (``interval``
-config) lives there, not here.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import cast
-
-from sqlglot import exp
-
-from interlace.engines.base import EngineCaps
-from interlace.exceptions import PlanError
-from interlace.ir.relation import SqlRelation, TableRef
-from interlace.state.interval import Interval
-from interlace.strategies.base import RowCounts, Strategy, _at, table_expr
-
-
-class IncrementalByTime(Strategy):
-    """``CREATE IF NOT EXISTS`` + ``DELETE`` the window + ``INSERT`` the window's rows."""
-
-    def __init__(self, time_column: str) -> None:
-        if not time_column:
-            raise PlanError("incremental_by_time requires a time_column")
-        self.time_column = time_column
-
-    def plan_statements(
-        self,
-        relation: SqlRelation,
-        target: TableRef,
-        caps: EngineCaps,
-        interval: Interval | None = None,
-        columns: Sequence[str] | None = None,
-    ) -> list[exp.Expression]:
-        if interval is None:
-            raise PlanError("incremental_by_time requires an interval to process")
-        query = relation.ast
-        table = table_expr(target)
-
-        def derived() -> exp.Subquery:
-            return cast("exp.Query", query.copy()).subquery("_s")
-
-        def window() -> exp.Expression:
-            column = exp.column(self.time_column)
-            return exp.And(
-                this=exp.GTE(this=column.copy(), expression=exp.Literal.string(interval.start.isoformat())),
-                expression=exp.LT(this=column.copy(), expression=exp.Literal.string(interval.end.isoformat())),
-            )
-
-        ensure = exp.Create(
-            this=table.copy(), kind="TABLE", exists=True, expression=exp.select("*").from_(derived()).limit(0)
-        )
-        delete = exp.Delete(this=table.copy(), where=exp.Where(this=window()))
-        insert = exp.Insert(this=table.copy(), expression=exp.select("*").from_(derived()).where(window()))
-        return [ensure, delete, insert]
-
-    def row_counts(self, counts: Sequence[int]) -> RowCounts:
-        # [ensure, delete window, insert window]: catchup deletes 0; restate rewrites
-        return RowCounts(inserted=_at(counts, 2), deleted=_at(counts, 1))