supertable 2.2.2__tar.gz → 2.2.4__tar.gz

{supertable-2.2.2/supertable.egg-info → supertable-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supertable
-Version: 2.2.2
+Version: 2.2.4
 Summary: SuperTable — versioned data lake library for SQL analytics on Parquet + Redis.
 Author: Levente Kupas
 Author-email: Levente Kupas <lkupas@kladnasoft.com>

{supertable-2.2.2 → supertable-2.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "supertable"
-version = "2.2.2"
+version = "2.2.4"
 description = "SuperTable — versioned data lake library for SQL analytics on Parquet + Redis."
 readme = "README.md"
 requires-python = ">=3.10"

{supertable-2.2.2 → supertable-2.2.4}/setup.py

@@ -19,7 +19,7 @@ long_description = readme.read_text(encoding="utf-8") if readme.exists() else ""
 
 setup(
     name="supertable",
-    version="2.2.2",
+    version="2.2.4",
     description="SuperTable — versioned data lake library for SQL analytics on Parquet + Redis.",
     long_description=long_description,
     long_description_content_type="text/markdown",

{supertable-2.2.2 → supertable-2.2.4}/supertable/__init__.py

@@ -25,7 +25,7 @@ See the ``supertable.demo`` package for runnable end-to-end demos and the
 project documentation for the full API surface.
 """
 
-__version__ = "2.2.2"
+__version__ = "2.2.4"
 
 # Re-export the core public surface so users can do ``from supertable import …``
 # instead of remembering submodule paths.

{supertable-2.2.2 → supertable-2.2.4}/supertable/config/settings.py

@@ -282,21 +282,6 @@ class Settings:
     SUPERTABLE_SHARE_PRESIGN_TTL: int = 14400                # SUPERTABLE_SHARE_PRESIGN_TTL (seconds, default 4h)
     SUPERTABLE_SHARE_REFRESH_BUFFER: int = 600               # SUPERTABLE_SHARE_REFRESH_BUFFER (seconds, refresh 10min before expiry)
 
-    # ── Storage GC (deferred deletion of sunset parquets + old snapshot JSONs) ──
-    # Sunset parquet files and old snapshot JSONs are never deleted by the
-    # writer directly. When either flag is enabled, the writer XADDs paths
-    # to a per-table Redis STREAM after a successful leaf-CAS. A separate
-    # cleaner daemon (``python -m supertable.gc.cleaner``) drains entries
-    # older than ``SUPERTABLE_GC_DELAY_SEC`` and calls ``storage.delete()``.
-    # The delay window avoids the race where an in-flight reader's
-    # ``parquet_scan([...])`` resolves a file path right before the writer
-    # deletes it. Defaults below preserve today's behaviour (off, unlimited).
-    SUPERTABLE_SNAPSHOT_RETENTION: int = 0                   # SUPERTABLE_SNAPSHOT_RETENTION (0 = keep all snapshot JSONs)
-    SUPERTABLE_SUNSET_GC_ENABLED: bool = False               # SUPERTABLE_SUNSET_GC_ENABLED (delete sunset parquets via queue)
-    SUPERTABLE_GC_DELAY_SEC: int = 1800                      # SUPERTABLE_GC_DELAY_SEC (min age before cleaner deletes)
-    SUPERTABLE_GC_SLEEP_SEC: int = 60                        # SUPERTABLE_GC_SLEEP_SEC (cleaner loop sleep)
-    SUPERTABLE_GC_BATCH_SIZE: int = 500                      # SUPERTABLE_GC_BATCH_SIZE (max entries processed per table per tick)
-
 
     # ── Convenience properties ───────────────────────────────────────
 
@@ -543,13 +528,6 @@ def _build_settings() -> Settings:
         # Data Sharing
         SUPERTABLE_SHARE_PRESIGN_TTL=_env_int("SUPERTABLE_SHARE_PRESIGN_TTL", 14400),
         SUPERTABLE_SHARE_REFRESH_BUFFER=_env_int("SUPERTABLE_SHARE_REFRESH_BUFFER", 600),
-
-        # ── Storage GC ───────────────────────────────────────────────
-        SUPERTABLE_SNAPSHOT_RETENTION=_env_int("SUPERTABLE_SNAPSHOT_RETENTION", 0),
-        SUPERTABLE_SUNSET_GC_ENABLED=_env_bool("SUPERTABLE_SUNSET_GC_ENABLED", False),
-        SUPERTABLE_GC_DELAY_SEC=_env_int("SUPERTABLE_GC_DELAY_SEC", 1800),
-        SUPERTABLE_GC_SLEEP_SEC=_env_int("SUPERTABLE_GC_SLEEP_SEC", 60),
-        SUPERTABLE_GC_BATCH_SIZE=_env_int("SUPERTABLE_GC_BATCH_SIZE", 500),
     )
 
 

{supertable-2.2.2 → supertable-2.2.4}/supertable/data_writer.py

@@ -13,7 +13,6 @@ from polars import DataFrame
 from supertable.config.defaults import logger
 from supertable.config.settings import settings
 from supertable.errors import SuperTableNotFoundError, TableNotFoundError
-from supertable.gc.queue import collect_old_snapshot_paths, enqueue_deletions
 from supertable.monitoring.partitions import MONITORING_SINK_TABLES
 from supertable.monitoring_writer import MonitoringWriter  # async monitoring
 from supertable.super_table import SuperTable
@@ -571,46 +570,6 @@ class DataWriter:
                     self.catalog.bump_root(self.super_table.organization, self.super_table.super_name, now_ms=now_ms)
                 mark("bump_root")
 
-                # --- Enqueue deferred deletions (post-CAS, post-bump) ----------
-                # Strict ordering matters: leaf-CAS + root-bump have committed
-                # the new snapshot as the authoritative state. Only NOW is it
-                # safe to schedule physical deletion of files that the old
-                # snapshot still references — any reader that loaded the
-                # previous leaf payload will finish before the cleaner's delay
-                # window expires.
-                #
-                # Both blocks are best-effort: enqueue_deletions and
-                # collect_old_snapshot_paths swallow Redis/storage errors and
-                # log a warning. A GC failure must never fail the write.
-                try:
-                    _org = self.super_table.organization
-                    _sup = self.super_table.super_name
-                    if settings.SUPERTABLE_SUNSET_GC_ENABLED and sunset_files:
-                        enqueue_deletions(
-                            self.catalog,
-                            _org, _sup, simple_name,
-                            "parquet",
-                            list(sunset_files),
-                            write_id=qid,
-                        )
-                    if settings.SUPERTABLE_SNAPSHOT_RETENTION > 0:
-                        old_paths = collect_old_snapshot_paths(
-                            new_snapshot_dict,
-                            self.super_table.storage,
-                            settings.SUPERTABLE_SNAPSHOT_RETENTION,
-                        )
-                        if old_paths:
-                            enqueue_deletions(
-                                self.catalog,
-                                _org, _sup, simple_name,
-                                "snapshot",
-                                old_paths,
-                                write_id=qid,
-                            )
-                except Exception as e:
-                    logger.warning(lp(f"GC enqueue failed (write still succeeded): {e}"))
-                mark("gc_enqueue")
-
                 # --- Store schema + table name in Redis (permanent, not cache) ---
                 try:
                     schema_raw = new_snapshot_dict.get("schema", {})
@@ -795,9 +754,14 @@ class DataWriter:
              qualify — large files are left untouched. ``small_only=False``
              rewrites every resource regardless of size.
           5. Commit the new snapshot via ``simple_table.update``,
-             leaf-CAS, ``bump_root``, and the same GC enqueue +
+             leaf-CAS, ``bump_root``, optional mirroring, and the same
              monitoring + audit pipeline as ``write``.
 
+        Compaction does **not** garbage-collect: the small files it
+        merges away are left in storage (still referenced by older
+        snapshot versions for time-travel) for an external GC to
+        reclaim later.
+
         Concurrency: compaction is serialised against writes through
         the same per-simple lock. A concurrent ``write()`` either
         runs first (compaction sees the updated snapshot) or waits.
@@ -994,12 +958,10 @@ class DataWriter:
             # Critical filter: a file produced by Phase A (tombstone
             # compaction) can be picked up as a small-file candidate
             # by Phase B (compact_resources) and then sunset there.
-            # If we leave it in ``all_new_resources`` it lands in the
-            # new snapshot **and** in ``all_sunset`` (slated for GC
-            # deletion). 30 min later GC deletes the file while the
-            # snapshot still references it — readers fail with
-            # FileNotFoundError. Filter the file out of new_resources
-            # when it also appears in any sunset set.
+            # If we leave it in ``all_new_resources`` it would land in the
+            # new snapshot **and** in ``all_sunset`` at the same time.
+            # Filter the file out of new_resources when it also appears
+            # in any sunset set so the snapshot stays consistent.
             all_sunset = set(tomb_sunset) | set(small_sunset)
             all_new_resources = [
                 r for r in (list(tomb_new_resources) + list(small_new_resources))
@@ -1011,7 +973,7 @@ class DataWriter:
             result["total_rows_written"] = small_total_rows
 
             # Short-circuit: nothing to do, skip the snapshot rewrite
-            # and the leaf-CAS / root-bump / GC / mirror path. BUT do
+            # and the leaf-CAS / root-bump / mirror path. BUT do
             # NOT return here — execution must fall through to the
             # ``finally`` (which releases the lock) AND the monitoring
             # + audit emission blocks after the try/finally so the
@@ -1115,36 +1077,6 @@ class DataWriter:
                 )
                 mark("bump_root")
 
-                # --- GC enqueue (same flags as write) ----------------------------
-                try:
-                    _org = self.super_table.organization
-                    _sup = self.super_table.super_name
-                    if settings.SUPERTABLE_SUNSET_GC_ENABLED and all_sunset:
-                        enqueue_deletions(
-                            self.catalog,
-                            _org, _sup, simple_name,
-                            "parquet",
-                            list(all_sunset),
-                            write_id=qid,
-                        )
-                    if settings.SUPERTABLE_SNAPSHOT_RETENTION > 0:
-                        old_paths = collect_old_snapshot_paths(
-                            new_snapshot_dict,
-                            self.super_table.storage,
-                            settings.SUPERTABLE_SNAPSHOT_RETENTION,
-                        )
-                        if old_paths:
-                            enqueue_deletions(
-                                self.catalog,
-                                _org, _sup, simple_name,
-                                "snapshot",
-                                old_paths,
-                                write_id=qid,
-                            )
-                except Exception as e:
-                    logger.warning(lp(f"GC enqueue failed (compact still succeeded): {e}"))
-                mark("gc_enqueue")
-
                 # --- Mirroring ---------------------------------------------------
                 try:
                     MirrorFormats.mirror_if_enabled(

{supertable-2.2.2 → supertable-2.2.4}/supertable/redis_catalog.py

@@ -1111,7 +1111,7 @@ return 1
     # ------------- Deletions (dangerous) -------------
 
     def delete_simple_table(self, org: str, sup: str, simple: str) -> bool:
-        """Delete a simple table's Redis meta (leaf pointer + lock + GC stream).
+        """Delete a simple table's Redis meta (leaf pointer + lock).
 
         This does **not** delete storage. Callers should delete storage first, then call this.
         """
@@ -1120,11 +1120,6 @@ return 1
         keys = [
             RK.meta_leaf(org, sup, simple),
             RK.lock_leaf(org, sup, simple),
-            # Nuke the deferred-deletion queue too — once the table is gone
-            # there is no point draining pending deletions through the
-            # cleaner, and leaving the stream around makes
-            # SimpleTable.delete observably non-idempotent in Redis.
-            RK.gc_pending(org, sup, simple),
         ]
         try:
             # DEL returns number of keys removed

{supertable-2.2.2 → supertable-2.2.4}/supertable/redis_keys.py

@@ -729,83 +729,6 @@ def linked_share_doc(org: str, sup: str, link_id: str) -> str:
     )
 
 
-# --- GC / Deferred deletion queue ------------------------------------------ #
-#
-# Per-table Redis STREAM holding paths scheduled for delayed physical
-# deletion (sunset parquet files, pruned snapshot JSONs). Producers
-# (``data_writer``) XADD entries after the leaf-CAS commit succeeds; the
-# org-level ``gc.cleaner`` daemon XRANGEs entries older than
-# ``SUPERTABLE_GC_DELAY_SEC`` and ``storage.delete()`` them, then XDELs.
-#
-# The stream lives under the lakes scope so a supertable-wide drop
-# (``catalog.delete_super_table``) naturally nukes it via the standard
-# ``super_table_pattern`` SCAN.
-
-def gc_pending(org: str, sup: str, simple: str) -> str:
-    """Per-table deferred-deletion stream (STREAM)."""
-    return (
-        f"{SUPERTABLE_PREFIX}:{_safe('org', org)}:{LAKES_SCOPE}"
-        f":{_safe('sup', sup)}:gc:pending:doc:{_safe('simple', simple)}"
-    )
-
-
-def gc_pending_pattern(org: str, sup: str) -> str:
-    """SCAN pattern matching every GC stream in one supertable."""
-    return (
-        f"{SUPERTABLE_PREFIX}:{_safe('org', org)}:{LAKES_SCOPE}"
-        f":{_safe('sup', sup)}:gc:pending:doc:*"
-    )
-
-
-def gc_pending_pattern_for_org(org: str) -> str:
-    """SCAN pattern matching every GC stream across every supertable in one org.
-
-    Used by the per-org cleaner daemon to discover all per-table streams
-    it must drain.
-    """
-    return (
-        f"{SUPERTABLE_PREFIX}:{_safe('org', org)}:{LAKES_SCOPE}"
-        f":*:gc:pending:doc:*"
-    )
-
-
-def gc_pending_pattern_all_orgs() -> str:
-    """SCAN pattern matching every GC stream across every org.
-
-    Used by the ``--all-orgs`` cleaner mode to discover the full set of
-    orgs that have pending deletions.
-    """
-    return f"{SUPERTABLE_PREFIX}:*:{LAKES_SCOPE}:*:gc:pending:doc:*"
-
-
-def parse_gc_pending_key(key: str) -> Optional[Tuple[str, str, str]]:
-    """Extract ``(org, sup, simple)`` from a GC pending stream key.
-
-    Returns ``None`` when the key does not match the
-    ``supertable:{org}:lakes:{sup}:gc:pending:doc:{simple}`` shape.
-    This is the canonical way for the cleaner to walk SCAN output and
-    recover the per-table coordinates without re-implementing the parse
-    rules.
-    """
-    if not isinstance(key, str):
-        return None
-    parts = key.split(":")
-    # supertable : {org} : lakes : {sup} : gc : pending : doc : {simple}
-    if (
-        len(parts) == 8
-        and parts[0] == SUPERTABLE_PREFIX
-        and parts[2] == LAKES_SCOPE
-        and parts[4] == "gc"
-        and parts[5] == "pending"
-        and parts[6] == "doc"
-        and parts[1]
-        and parts[3]
-        and parts[7]
-    ):
-        return parts[1], parts[3], parts[7]
-    return None
-
-
 # --- Data Quality (dataisland-core quality module owns its sub-structure) #
 
 def quality_prefix(org: str, sup: str) -> str:

{supertable-2.2.2 → supertable-2.2.4}/supertable/simple_table.py

@@ -260,6 +260,56 @@ class SimpleTable:
         data = self.storage.read_json(path)
         return data, path
 
+    def export_to(self, target_dir: str, compression_level: int = 3, small_only: bool = False):
+        """Write a standalone copy of the current data into ``target_dir``.
+
+        Reads the current snapshot's parquet resources and re-writes them
+        as memory-bounded parquet chunks (each ~``max_memory_chunk_size``,
+        from the per-table config or the global default) under
+        ``target_dir``.  This is a pure copy: it does NOT create a new
+        snapshot, advance the Redis leaf, or touch ``data/``/``snapshots/``.
+
+        Args:
+            target_dir: destination directory for the exported parquet
+                files (created if missing).  Typically an
+                ``export/<timestamp>/`` folder next to ``data/``.
+            compression_level: zstd level for the exported parquet.
+            small_only: when False (default) every resource is read and
+                re-chunked; when True only files smaller than
+                ``max_memory_chunk_size`` are included.
+
+        Returns:
+            ``dict`` with ``files`` (list of written paths),
+            ``files_written``, ``total_rows`` and ``total_bytes``.
+        """
+        from supertable.processing import compact_resources
+
+        snapshot, _path = self.get_simple_table_snapshot()
+        table_config = self.catalog.get_table_config(
+            self.super_table.organization,
+            self.super_table.super_name,
+            self.simple_name,
+        ) or {}
+
+        _considered, total_rows, new_resources, _sunset = compact_resources(
+            snapshot=snapshot,
+            data_dir=target_dir,
+            compression_level=compression_level,
+            table_config=table_config,
+            small_only=small_only,
+        )
+
+        files = [r.get("file") for r in new_resources if isinstance(r, dict) and r.get("file")]
+        total_bytes = sum(
+            int(r.get("file_size") or 0) for r in new_resources if isinstance(r, dict)
+        )
+        return {
+            "files": files,
+            "files_written": len(files),
+            "total_rows": int(total_rows),
+            "total_bytes": int(total_bytes),
+        }
+
     def update(self, new_resources, sunset_files, model_df, last_snapshot=None, last_snapshot_path=None, lineage=None, profiler: Optional[Profiler] = None):
         """
         Build and write a new heavy snapshot on storage.

{supertable-2.2.2 → supertable-2.2.4}/supertable/tests/test_data_writer_compact.py

@@ -38,8 +38,6 @@ _P_COMPACT_TOMB  = f"{_MOD}.compact_tombstones"
 _P_TOMB_THRESH   = f"{_MOD}._tombstone_threshold"
 _P_MIRROR        = f"{_MOD}.MirrorFormats"
 _P_MON_WRITER    = f"{_MOD}.MonitoringWriter"
-_P_ENQUEUE       = f"{_MOD}.enqueue_deletions"
-_P_COLLECT_OLD   = f"{_MOD}.collect_old_snapshot_paths"
 _P_AUDIT         = f"{_MOD}._audit_emit"
 _P_SETTINGS      = f"{_MOD}.settings"
 
@@ -85,12 +83,9 @@ def _mk_simple_mock(snap: dict, *, snap_path: str = "/snap/v1.json",
     return mock
 
 
-def _stub_settings(*, sunset=False, retention=0):
-    """Build a fake ``settings`` object with GC flags."""
-    s = MagicMock()
-    s.SUPERTABLE_SUNSET_GC_ENABLED = sunset
-    s.SUPERTABLE_SNAPSHOT_RETENTION = retention
-    return s
+def _stub_settings():
+    """Build a fake ``settings`` object for patching."""
+    return MagicMock()
 
 
 def _build_writer():
@@ -604,80 +599,6 @@ class TestSnapshotCommit:
         dw.catalog.bump_root.assert_called_once()
 
 
-# ===========================================================================
-# 6. GC enqueue gating (same flags as write)
-# ===========================================================================
-
-
-class TestGCEnqueue:
-
-    @patch(_P_AUDIT)
-    @patch(_P_MON_WRITER)
-    @patch(_P_MIRROR)
-    @patch(_P_ENQUEUE)
-    @patch(_P_COLLECT_OLD, return_value=[])
-    @patch(_P_COMPACT_RES)
-    @patch(_P_COMPACT_TOMB, return_value=(0, [], set()))
-    @patch(_P_SETTINGS)
-    @patch(_P_SIMPLE_TABLE)
-    @patch(_P_CHECK_WRITE)
-    def test_sunset_gc_enqueue_when_flag_on(
-        self, mock_check_write, MockSimple, mock_settings_obj,
-        mock_compact_tomb, mock_compact_res, mock_collect_old,
-        mock_enqueue, MockMirror, MockMW, mock_audit,
-    ):
-        mock_settings_obj.SUPERTABLE_SUNSET_GC_ENABLED = True
-        mock_settings_obj.SUPERTABLE_SNAPSHOT_RETENTION = 0
-
-        dw = _build_writer()
-        snap = _snapshot([_resource("a"), _resource("b")])
-        mock_simple = _mk_simple_mock(snap)
-        MockSimple.return_value = mock_simple
-
-        new_res = [{"file": "c.parquet", "file_size": 5000, "columns": []}]
-        sunset = {"a", "b"}
-        mock_compact_res.return_value = (2, 200, new_res, sunset)
-        dw._get_table_config = MagicMock(return_value={})
-
-        dw.compact("admin", "tbl")
-
-        # parquet enqueue called with the sunset paths
-        parquet_calls = [
-            c for c in mock_enqueue.call_args_list
-            if c.args[4] == "parquet"
-        ]
-        assert len(parquet_calls) == 1
-        assert set(parquet_calls[0].args[5]) == sunset
-
-    @patch(_P_AUDIT)
-    @patch(_P_MON_WRITER)
-    @patch(_P_MIRROR)
-    @patch(_P_ENQUEUE)
-    @patch(_P_COLLECT_OLD, return_value=[])
-    @patch(_P_COMPACT_RES)
-    @patch(_P_COMPACT_TOMB, return_value=(0, [], set()))
-    @patch(_P_SETTINGS)
-    @patch(_P_SIMPLE_TABLE)
-    @patch(_P_CHECK_WRITE)
-    def test_no_gc_enqueue_when_flags_off(
-        self, mock_check_write, MockSimple, mock_settings_obj,
-        mock_compact_tomb, mock_compact_res, mock_collect_old,
-        mock_enqueue, MockMirror, MockMW, mock_audit,
-    ):
-        mock_settings_obj.SUPERTABLE_SUNSET_GC_ENABLED = False
-        mock_settings_obj.SUPERTABLE_SNAPSHOT_RETENTION = 0
-
-        dw = _build_writer()
-        snap = _snapshot([_resource("a")])
-        MockSimple.return_value = _mk_simple_mock(snap)
-        mock_compact_res.return_value = (1, 100, [{"file": "c", "file_size": 1, "columns": []}], {"a"})
-        dw._get_table_config = MagicMock(return_value={})
-
-        dw.compact("admin", "tbl")
-
-        mock_enqueue.assert_not_called()
-
-
 # ===========================================================================
 # 7. Monitoring lifecycle
 # ===========================================================================

{supertable-2.2.2 → supertable-2.2.4}/supertable/tests/test_redis_key_prefix.py

@@ -121,12 +121,6 @@ def _all_helpers() -> list[tuple[str, str, str]]:
         # ---- Schema -----------------------------------------------------
         ("schema",                       RK.schema(ORG, SUP, SIMPLE),          f"{lake_pre}:schema:doc:{SIMPLE}"),
 
-        # ---- GC pending (deferred-deletion stream) ---------------------
-        ("gc_pending",                   RK.gc_pending(ORG, SUP, SIMPLE),      f"{lake_pre}:gc:pending:doc:{SIMPLE}"),
-        ("gc_pending_pattern",           RK.gc_pending_pattern(ORG, SUP),      f"{lake_pre}:gc:pending:doc:*"),
-        ("gc_pending_pattern_for_org",   RK.gc_pending_pattern_for_org(ORG),   f"supertable:{ORG}:lakes:*:gc:pending:doc:*"),
-        ("gc_pending_pattern_all_orgs",  RK.gc_pending_pattern_all_orgs(),     "supertable:*:lakes:*:gc:pending:doc:*"),
-
         # ---- Linked shares ---------------------------------------------
         ("linked_share_index",           RK.linked_share_index(ORG, SUP),      f"{lake_pre}:linked_shares:index"),
         ("linked_share_doc",             RK.linked_share_doc(ORG, SUP, LINK),  f"{lake_pre}:linked_shares:doc:{LINK}"),
@@ -421,20 +415,6 @@ def test_parse_registry_key_returns_none_for_other_keys():
     assert RK.parse_registry_key(RK.app_master_mcp("lighthouse")) is None
 
 
-def test_parse_gc_pending_key_extracts_fields():
-    key = RK.gc_pending("acme", "demo", "orders")
-    assert RK.parse_gc_pending_key(key) == ("acme", "demo", "orders")
-
-
-def test_parse_gc_pending_key_returns_none_for_other_keys():
-    assert RK.parse_gc_pending_key(RK.meta_root("acme", "demo")) is None
-    assert RK.parse_gc_pending_key(RK.meta_leaf("acme", "demo", "orders")) is None
-    assert RK.parse_gc_pending_key(RK.lock_leaf("acme", "demo", "orders")) is None
-    assert RK.parse_gc_pending_key("supertable:acme:lakes:demo:gc:pending:doc:") is None
-    assert RK.parse_gc_pending_key("") is None
-    assert RK.parse_gc_pending_key(None) is None  # type: ignore[arg-type]
-
-
 def test_parse_monitor_partition_key_extracts_fields():
     key = RK.monitor_partition("acme", "writes", "2026-06-09")
     assert RK.parse_monitor_partition_key(key) == ("acme", "writes", "2026-06-09")
@@ -442,7 +422,6 @@ def test_parse_monitor_partition_key_extracts_fields():
 
 def test_parse_monitor_partition_key_returns_none_for_other_keys():
     assert RK.parse_monitor_partition_key(RK.meta_root("acme", "demo")) is None
-    assert RK.parse_monitor_partition_key(RK.gc_pending("acme", "demo", "t")) is None
     # Drain handle is rejected (7 segments, not 6)
     assert RK.parse_monitor_partition_key(
         RK.monitor_partition_drain("acme", "writes", "2026-06-09")

{supertable-2.2.2 → supertable-2.2.4/supertable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supertable
-Version: 2.2.2
+Version: 2.2.4
 Summary: SuperTable — versioned data lake library for SQL analytics on Parquet + Redis.
 Author: Levente Kupas
 Author-email: Levente Kupas <lkupas@kladnasoft.com>

{supertable-2.2.2 → supertable-2.2.4}/supertable.egg-info/SOURCES.txt

@@ -107,10 +107,6 @@ supertable/engine/tests/__init__.py
 supertable/engine/tests/conftest.py
 supertable/engine/tests/test_dedup_read.py
 supertable/engine/tests/test_engine.py
-supertable/gc/__init__.py
-supertable/gc/cleaner.py
-supertable/gc/daemon.py
-supertable/gc/queue.py
 supertable/locking/__init__.py
 supertable/locking/file_lock.py
 supertable/locking/redis_lock.py
@@ -158,9 +154,6 @@ supertable/tests/test_data_writer_comprehensive.py
 supertable/tests/test_data_writer_tombstones.py
 supertable/tests/test_dedup_on_read_write.py
 supertable/tests/test_errors.py
-supertable/tests/test_gc_cleaner.py
-supertable/tests/test_gc_daemon.py
-supertable/tests/test_gc_queue.py
 supertable/tests/test_meta_reader.py
 supertable/tests/test_monitoring_partitions.py
 supertable/tests/test_monitoring_sink_guard.py

supertable-2.2.2/supertable/gc/__init__.py

@@ -1,26 +0,0 @@
-# route: supertable.gc
-"""
-Deferred-deletion garbage collection for SuperTable storage.
-
-The data writer never deletes files inline. When the GC flags are enabled
-(``SUPERTABLE_SUNSET_GC_ENABLED`` / ``SUPERTABLE_SNAPSHOT_RETENTION``) the
-writer XADDs paths to a per-table Redis STREAM after a successful leaf-CAS.
-A long-running ``GCCleaner`` daemon (one per org) drains entries older than
-``SUPERTABLE_GC_DELAY_SEC`` and calls ``storage.delete()`` on each path.
-
-The delay window is what makes deletion safe under concurrent reads: a
-query that resolved the leaf payload right before the writer committed
-finishes long before the cleaner touches the file.
-"""
-
-from supertable.gc.queue import (
-    collect_old_snapshot_paths,
-    enqueue_deletions,
-    nuke_stream,
-)
-
-__all__ = [
-    "collect_old_snapshot_paths",
-    "enqueue_deletions",
-    "nuke_stream",
-]