tinybird-toolset 2.5.5__tar.gz → 2.6.1__tar.gz

{tinybird_toolset-2.5.5/src/tinybird_toolset.egg-info → tinybird_toolset-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinybird-toolset
-Version: 2.5.5
+Version: 2.6.1
 Home-page: https://gitlab.com/tinybird/clickhouse-toolset
 Author: Tinybird.co
 Author-email: support@tinybird.co

{tinybird_toolset-2.5.5 → tinybird_toolset-2.6.1}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, Extension
 
 NAME = 'tinybird-toolset'
-VERSION = '2.5.5'
+VERSION = '2.6.1'
 
 # Shared metadata for both the full (extension) build and the metadata-only
 # fallback below, so the two setup() calls can't drift apart.

{tinybird_toolset-2.5.5 → tinybird_toolset-2.6.1}/src/chtoolset/query.py

@@ -21,6 +21,8 @@ from chtoolset._query import replace_tables, \
     get_columns_from_create_query, \
     normalize_table_column, \
     validate_ttl, \
+    validate_partition_key, \
+    check_ttl_partition_compatibility, \
     parse_create_materialized_view_target_table as _parse_create_materialized_view_target_table
 
 from typing import Optional, TypedDict

{tinybird_toolset-2.5.5 → tinybird_toolset-2.6.1/src/tinybird_toolset.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinybird-toolset
-Version: 2.5.5
+Version: 2.6.1
 Home-page: https://gitlab.com/tinybird/clickhouse-toolset
 Author: Tinybird.co
 Author-email: support@tinybird.co

{tinybird_toolset-2.5.5 → tinybird_toolset-2.6.1}/src/tinybird_toolset.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/tinybird_toolset.egg-info/dependency_links.txt
 src/tinybird_toolset.egg-info/requires.txt
 src/tinybird_toolset.egg-info/top_level.txt
 tests/test_check_compatible_types.py
+tests/test_check_ttl_partition_compatibility.py
 tests/test_check_write_query.py
 tests/test_chquery.py
 tests/test_convert_to_row_binary.py
@@ -25,4 +26,5 @@ tests/test_replace_tables.py
 tests/test_replace_tables_backward_compat.py
 tests/test_rewrite_aggregation_states.py
 tests/test_tables.py
+tests/test_validate_partition_key.py
 tests/test_validate_ttl.py

tinybird_toolset-2.6.1/tests/test_check_ttl_partition_compatibility.py

@@ -0,0 +1,175 @@
+import unittest
+from chtoolset import query as chquery
+
+
+class TestCheckTTLPartitionCompatibility(unittest.TestCase):
+    def test_checked_and_compatible(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 1 MONTH",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertTrue(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_checked_and_compatible_uses_interval_count(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 90 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertTrue(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_checked_and_incompatible(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertTrue(result["checked"])
+        self.assertIsNotNone(result["error"])
+        self.assertIn("shorter than the partition key period", result["error"])
+
+    def test_mixed_where_clause_ttl_is_not_checked(self):
+        # A WHERE clause makes the whole statement ineligible for ttl_only_drop_parts,
+        # including when it also contains an unconditional TTL.
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "status", "type": "String"},
+            ],
+            ttl="ts + INTERVAL 1 MONTH, ts + INTERVAL 1 DAY WHERE status = 'expired'",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_a_ttl_clause_is_unrecognized(self):
+        # An unrecognized unconditional TTL remains unchecked; the WHERE clause also makes the
+        # whole statement ineligible for the optimization.
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "other_col", "type": "DateTime"},
+                {"name": "flag", "type": "UInt8"},
+            ],
+            ttl="toDateTime(other_col) + INTERVAL 1 DAY, ts + INTERVAL 1 MONTH WHERE flag = 1",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+        # validate_ttl, by contrast, silently accepts it - confirming the gap this function closes.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "other_col", "type": "DateTime"},
+                    {"name": "flag", "type": "UInt8"},
+                ],
+                ttl="toDateTime(other_col) + INTERVAL 1 DAY, ts + INTERVAL 1 MONTH WHERE flag = 1",
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_not_checked_when_only_where_ttl_exists(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "flag", "type": "UInt8"},
+            ],
+            ttl="ts + INTERVAL 1 DAY WHERE flag = 1",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_ttl_column_differs_from_partition_column(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "updated_at", "type": "DateTime"},
+            ],
+            ttl="updated_at + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_for_composite_partition_key(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[
+                {"name": "ts", "type": "DateTime"},
+                {"name": "k", "type": "String"},
+            ],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts), k",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_for_unrecognized_partition_function(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="intDiv(toUInt32(ts), 86400)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_no_partition_key(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="ts + INTERVAL 7 DAY",
+            sorting_key="ts",
+            primary_key="ts",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_when_no_ttl(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+    def test_not_checked_on_malformed_ttl(self):
+        result = chquery.check_ttl_partition_compatibility(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            ttl="this is not a valid ttl !!!",
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertFalse(result["checked"])
+        self.assertIsNone(result["error"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tinybird_toolset-2.6.1/tests/test_validate_partition_key.py

@@ -0,0 +1,150 @@
+import unittest
+from chtoolset import query as chquery
+
+
+class TestValidatePartitionKey(unittest.TestCase):
+    def test_valid_empty_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="",
+            )
+        )
+
+    def test_valid_hourly_partition_key(self):
+        # Hour is the floor - allowed.
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="toStartOfHour(ts)",
+            )
+        )
+
+    def test_valid_daily_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="toDate(ts)",
+            )
+        )
+
+    def test_valid_monthly_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfMinute(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_second_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfSecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_five_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfFiveMinutes(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_ten_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfTenMinutes(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_fifteen_minute_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfFifteenMinutes(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_five_minute_singular_alias_partition_key(self):
+        # toStartOfFiveMinute (singular) is a registered alias for toStartOfFiveMinutes.
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toStartOfFiveMinute(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_millisecond_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime64(3)"}],
+            partition_key="toStartOfMillisecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_microsecond_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime64(6)"}],
+            partition_key="toStartOfMicrosecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_nanosecond_partition_key(self):
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime64(9)"}],
+            partition_key="toStartOfNanosecond(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_invalid_yyyymmddhhmmss_partition_key(self):
+        # Packs the full date+time down to the second - no coarsening at all.
+        err = chquery.validate_partition_key(
+            columns=[{"name": "ts", "type": "DateTime"}],
+            partition_key="toYYYYMMDDhhmmss(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("finer than hourly", err)
+
+    def test_valid_skipped_for_composite_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "k", "type": "String"},
+                ],
+                partition_key="toStartOfMinute(ts), k",
+            )
+        )
+
+    def test_valid_skipped_for_unrecognized_function(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "ts", "type": "DateTime"}],
+                partition_key="intDiv(toUInt32(ts), 60)",
+            )
+        )
+
+    def test_valid_skipped_for_bare_column(self):
+        self.assertIsNone(
+            chquery.validate_partition_key(
+                columns=[{"name": "k", "type": "String"}],
+                partition_key="k",
+            )
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

{tinybird_toolset-2.5.5 → tinybird_toolset-2.6.1}/tests/test_validate_ttl.py

@@ -389,6 +389,254 @@ class TestValidateTTL(unittest.TestCase):
                 primary_key="ts",
             )
 
+    # --- Partition key / TTL granularity ---
+    def test_invalid_ttl_finer_than_partition_month_vs_day(self):
+        err = chquery.validate_ttl(
+            ttl="ts + INTERVAL 7 DAY",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_invalid_ttl_finer_than_partition_month_vs_week(self):
+        err = chquery.validate_ttl(
+            ttl="ts + INTERVAL 1 WEEK",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_valid_ttl_interval_count_is_included_in_duration(self):
+        # 90 DAY is comparable to 3 MONTH for a monthly partition; the DAY unit alone
+        # must not cause a rejection.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 90 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_ttl_interval_does_not_cover_longest_partition_period(self):
+        err = chquery.validate_ttl(
+            ttl="ts + INTERVAL 30 DAY",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_valid_ttl_interval_covers_longest_partition_period(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 31 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_valid_ttl_coarser_than_partition_month_vs_day(self):
+        # TTL is monthly, partition is daily: whole day-partitions still expire together.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 3 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toDate(ts)",
+            )
+        )
+
+    def test_valid_ttl_matches_partition_granularity(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 1 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_valid_no_partition_key_skips_granularity_check(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_different_column(self):
+        # TTL and partition key are on different columns; the relationship is unknown, so no check is applied.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "inserted_at", "type": "DateTime"},
+                ],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(inserted_at)",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_composite_partition_key(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "k", "type": "String"},
+                ],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts), k",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_unrecognized_partition_function(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 7 DAY",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="intDiv(toUInt32(ts), 86400)",
+            )
+        )
+
+    def test_invalid_bare_column_ttl_with_partition_key(self):
+        # No INTERVAL at all: the TTL fires the instant the raw column value is reached,
+        # which is finer than any partition granularity.
+        err = chquery.validate_ttl(
+            ttl="ts",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than the partition key period", err)
+
+    def test_valid_mixed_where_clause_ttl_skips_part_drop_check(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 1 DAY, ts + INTERVAL 1 DAY WHERE status = 'expired'",
+                columns=[
+                    {"name": "ts", "type": "DateTime"},
+                    {"name": "status", "type": "String"},
+                ],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_fixed_interval_can_be_shorter_than_calendar_truncation(self):
+        # A month can contain 31 days, so late rows in that month can be born expired.
+        err = chquery.validate_ttl(
+            ttl="toStartOfMonth(ts) + INTERVAL 30 DAY",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than its truncation period", err)
+
+    def test_valid_matching_calendar_interval_and_truncation(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfMonth(ts) + INTERVAL 1 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_valid_equivalent_calendar_interval_and_truncation(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfQuarter(ts) + INTERVAL 3 MONTH",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toStartOfQuarter(ts)",
+            )
+        )
+
+    def test_valid_long_interval_with_truncated_base_finer_than_partition(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfDay(ts) + INTERVAL 1 YEAR",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toYYYYMM(ts)",
+            )
+        )
+
+    def test_invalid_interval_shorter_than_ttl_truncation(self):
+        err = chquery.validate_ttl(
+            ttl="toStartOfMonth(ts) + INTERVAL 5 MINUTE",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+            partition_key="toYYYYMM(ts)",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than its truncation period", err)
+        self.assertIn("expire as soon as they are inserted", err)
+
+    def test_invalid_interval_shorter_than_truncation_without_partition_key(self):
+        err = chquery.validate_ttl(
+            ttl="toStartOfHour(ts) + INTERVAL 5 MINUTE",
+            columns=[{"name": "ts", "type": "DateTime"}],
+            sorting_key="ts",
+            primary_key="ts",
+        )
+        self.assertIsNotNone(err)
+        self.assertIn("shorter than its truncation period", err)
+
+    def test_valid_granularity_check_skipped_for_multi_minute_partition(self):
+        # toStartOfFiveMinutes isn't a recognized partition granularity (IntervalKind has no
+        # level between Minute and Hour), so the check is skipped rather than risk a false accept.
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="ts + INTERVAL 1 MINUTE",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toStartOfFiveMinutes(ts)",
+            )
+        )
+
+    def test_valid_granularity_check_skipped_for_multi_minute_ttl_truncation(self):
+        self.assertIsNone(
+            chquery.validate_ttl(
+                ttl="toStartOfFiveMinutes(ts) + INTERVAL 1 HOUR",
+                columns=[{"name": "ts", "type": "DateTime"}],
+                sorting_key="ts",
+                primary_key="ts",
+                partition_key="toStartOfTenMinutes(ts)",
+            )
+        )
 
     # --- Regression guard: sequential throwing calls must not crash ---
     def test_sequential_throwing_calls_do_not_crash(self):