mainsequence-metatable 0.1.33.dev63__tar.gz → 0.1.34__tar.gz

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.33.dev63
+Version: 0.1.34
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/docs/adr/api/0015-timescale-compression-and-retention-policies.md

@@ -101,6 +101,14 @@ application migrations and other engines are unchanged. If the DataSource later
 uses a different login, existing jobs keep running as the old one until the
 tables are reassigned.
 
+Managed finalization transfers ownership of an ordinary table to the API login
+before converting it, in the same transaction. Converting first and then
+reassigning a populated hypertable tries to reassign its internal chunks;
+TimescaleDB 2.10.2 rejects that when the login lacks `CREATE` on
+`_timescaledb_internal`. The corrected order requires no new grant and migrates
+existing rows in place. Conversion failure rolls ownership back; an already
+current hypertable keeps its owner and data.
+
 Each policy change is recorded in the `physical_operation` journal as
 `timescale_policy`, with the requesting User. System migration
 `0009_timescale_policies` adds that kind, drops `time_index_table.partition_strategy`

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence-metatable"
-version = "0.1.33.dev63"
+version = "0.1.34"
 description = "Main Sequence MetaTables Python client and standalone API"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/src/mainsequence_metatable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.33.dev63
+Version: 0.1.34
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/src/metatables/api/backend/backends/timescale.py

@@ -329,13 +329,19 @@ def ensure_hypertable(source, *, schema: str, table: str, time_index_name: str)
             with connection.cursor() as cursor:
                 if _version(cursor) is None:
                     raise TimescaleError("timescale_extension_missing")
+                # Re-own the ordinary table before conversion. Reassigning a
+                # populated hypertable afterwards also reassigns its chunks,
+                # requiring CREATE on Timescale's internal schema. The API login
+                # already owns the application schema and must own policy jobs.
+                # Both steps stay in this transaction, so conversion failures
+                # restore the former owner as well as the ordinary table.
+                _own(cursor, schema, table)
                 if _compression_enabled(cursor, schema, table) is None:
                     cursor.execute(
                         "SELECT create_hypertable(%s::regclass, %s::name, "
                         "create_default_indexes => FALSE, if_not_exists => TRUE, migrate_data => TRUE)",
                         [sql.Identifier(schema, table).as_string(connection), time_index_name],
                     )
-                _own(cursor, schema, table)
             connection.commit()
         except TimescaleError:
             connection.rollback()

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/tests/operations/test_timescale_policies.py

@@ -102,3 +102,74 @@ def test_time_index_tables_become_hypertables_only_on_timescale(kind, strategy,
     expected = [{"source": calls[0]["source"] if calls else None, "schema": "public",
                  "table": "prices", "time_index_name": "observed_at"}]
     assert calls == (expected if converted else [])
+
+
+@pytest.mark.parametrize("already_hypertable", [False, True])
+@pytest.mark.parametrize("conversion_fails", [False, True])
+def test_conversion_needs_no_internal_schema_grant_and_rolls_back_owner(
+    monkeypatch, already_hypertable, conversion_fails,
+):
+    """Model PostgreSQL ownership checks without granting internal-schema CREATE.
+
+    A chunk ownership transfer requires that grant; re-owning an ordinary table
+    only requires the application schema. Failed conversion must restore both
+    ownership and storage state, while a current development table stays current.
+    """
+    from contextlib import contextmanager
+
+    import psycopg2
+
+    state = {"owner": "api" if already_hypertable else "mt_owner",
+             "hypertable": already_hypertable, "rows": (("2026-01-01", "asset", 123.5),)}
+    before = state.copy()
+    commits, rollbacks = [], []
+
+    class Cursor:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+        def execute(self, statement, parameters):
+            # This is the only DDL issued outside _own by ensure_hypertable.
+            assert statement.startswith("SELECT create_hypertable(")
+            if conversion_fails:
+                raise psycopg2.errors.CheckViolation("conversion failed")
+            state["hypertable"] = True
+
+    class Connection:
+        def cursor(self):
+            return Cursor()
+
+        def commit(self):
+            commits.append(True)
+
+        def rollback(self):
+            rollbacks.append(True)
+            state.update(before)
+
+    @contextmanager
+    def connection(*args, **kwargs):
+        yield Connection()
+
+    def own(*args):
+        if state["owner"] != "api":
+            if state["hypertable"]:
+                raise psycopg2.errors.InsufficientPrivilege("permission denied for schema _timescaledb_internal")
+            state["owner"] = "api"
+
+    monkeypatch.setattr(timescale, "open_postgresql_connection", connection)
+    monkeypatch.setattr(timescale.sql, "Identifier", lambda *parts: SimpleNamespace(as_string=lambda _: ".".join(parts)))
+    monkeypatch.setattr(timescale, "_version", lambda cursor: "2.10.2")
+    monkeypatch.setattr(timescale, "_compression_enabled", lambda *args: False if state["hypertable"] else None)
+    monkeypatch.setattr(timescale, "_own", own)
+    if conversion_fails and not already_hypertable:
+        with pytest.raises(timescale.TimescaleError, match="timescale_hypertable_failed"):
+            timescale.ensure_hypertable(None, schema="public", table="prices", time_index_name="time_index")
+        assert state == before
+        assert len(rollbacks) == 1 and not commits
+    else:
+        timescale.ensure_hypertable(None, schema="public", table="prices", time_index_name="time_index")
+        assert state == {**before, "owner": "api", "hypertable": True}
+        assert len(commits) == 1 and not rollbacks

{mainsequence_metatable-0.1.33.dev63 → mainsequence_metatable-0.1.34}/uv.lock

@@ -825,7 +825,7 @@ mcp = [
 
 [[package]]
 name = "mainsequence-metatable"
-version = "0.1.33"
+version = "0.1.34"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },