@@ -289,7 +289,9 @@ def export_partitioned(
 
         key_col = "__damast_partition_key__"
         collected = self.lazyframe.with_columns(strategy.key_expr().alias(key_col)).collect()
-        warn_on_local_time_buckets(collected[key_col])
+        if strategy.time_zone is None:
+            # only an accidental local-time bucketing is worth a warning
+            warn_on_local_time_buckets(collected[key_col])
 
         written: list[Path] = []
         # as_dict=False + re-deriving the key from the partition itself (rather than
 
@@ -31,6 +31,11 @@ class PartitionStrategy(ABC):
     :meth:`AnnotatedDataFrame.export_partitioned`.
     """
 
+    #: Time zone this strategy deliberately buckets in, if any. Setting it states that a
+    #: non-UTC bucketing is intended and suppresses the warning from
+    #: :func:`warn_on_local_time_buckets`.
+    time_zone: str | None = None
+
     @abstractmethod
     def key_expr(self) -> polars.Expr:
         """A polars expression computing this strategy's per-row partition key."""
@@ -72,24 +77,38 @@ class ByTime(PartitionStrategy):
     for one file per hour, ``"1d"`` for one file per day, ``"1w"`` per week.
 
     .. note::
-        Truncation happens in the timestamp column's own time zone, so a column in e.g.
-        ``Asia/Tokyo`` yields Tokyo-day buckets, not UTC-day buckets - the same instant then
-        lands in a differently named file. :meth:`AnnotatedDataFrame.export_partitioned` warns
-        about this; convert the column with ``dt.convert_time_zone("UTC")`` for UTC buckets.
-        A naive (zone-less) column is truncated as-is.
+        By default truncation happens in the timestamp column's own time zone, so a column in
+        e.g. ``Asia/Tokyo`` yields Tokyo-day buckets, not UTC-day buckets - the same instant
+        then lands in a differently named file, and
+        :meth:`AnnotatedDataFrame.export_partitioned` warns about it. Pass ``time_zone="UTC"``
+        to bucket by UTC regardless of how the column is zoned.
+
+    Example:
+
+    .. code-block:: python
+
+        # one file per UTC day, whatever zone the column carries
+        ByTime("timestamp", every="1d", time_zone="UTC")
     """
 
     def __init__(
         self,
         timestamp_column: str,
         every: str,
         *,
+        time_zone: str | None = None,
         format: str | None = None,
         prefix: str | None = None,
     ):
         """
         :param timestamp_column: Name of the datetime column to partition by
         :param every: Truncation interval, e.g. ``"1h"``, ``"1d"``, ``"1w"``
+        :param time_zone: Convert the column to this time zone before truncating, e.g.
+            ``"UTC"`` for UTC buckets or ``"Europe/Oslo"`` to bucket by local days on purpose.
+            The default (``None``) truncates in whatever zone the column carries, which is
+            polars' own behaviour. A naive (zone-less) column is read as UTC, so
+            ``time_zone="UTC"`` leaves it unchanged. Setting this states the intent, so the
+            local-time warning of :meth:`AnnotatedDataFrame.export_partitioned` is suppressed.
         :param format: Optional ``strftime`` format for the filename stem (default:
             automatically pick the coarsest representation matching the truncated value, e.g.
             ``"2026-09-14"`` for a day, ``"2026-09-14T13"`` for an hour). Use e.g.
@@ -100,11 +119,15 @@ def __init__(
         """
         self.timestamp_column = timestamp_column
         self.every = every
+        self.time_zone = time_zone
         self.format = format
         self.prefix = prefix
 
     def key_expr(self) -> polars.Expr:
-        return polars.col(self.timestamp_column).dt.truncate(self.every)
+        column = polars.col(self.timestamp_column)
+        if self.time_zone is not None:
+            column = column.dt.convert_time_zone(self.time_zone)
+        return column.dt.truncate(self.every)
 
     def filename(self, key: Any) -> str:
         stem = (
@@ -170,8 +193,8 @@ def warn_on_local_time_buckets(keys: polars.Series) -> None:
     column carrying e.g. ``Asia/Tokyo`` produces local-day buckets - the same instant lands
     in a different file than it would in UTC, and the resulting filenames cannot be read
     back without knowing that zone. Partitioning by local days is legitimate, so this only
-    warns; convert the column with ``dt.convert_time_zone("UTC")`` beforehand to get UTC
-    buckets.
+    warns; pass ``ByTime(..., time_zone="UTC")`` for UTC buckets, or name the zone explicitly
+    (:attr:`PartitionStrategy.time_zone`) to state the intent and silence this.
 
     :param keys: The materialized partition key column, as produced by
         :meth:`PartitionStrategy.key_expr`
@@ -186,8 +209,9 @@ def warn_on_local_time_buckets(keys: polars.Series) -> None:
         if time_zone is not None and time_zone != "UTC":
             logger.warning(
                 f"Partition key '{name}' is a datetime in time zone '{time_zone}', so its buckets"
-                f" (and the resulting filenames) follow {time_zone} days, not UTC days. Convert the"
-                f" column with dt.convert_time_zone('UTC') first if UTC buckets were intended."
+                f" (and the resulting filenames) follow {time_zone} days, not UTC days. Pass"
+                f" time_zone='UTC' if UTC buckets were intended, or time_zone='{time_zone}' to"
+                f" state that they were not."
             )
 
 
 
@@ -375,8 +375,8 @@ def test_expected_paths_names_do_not_match_a_non_utc_archive(tmp_path):
     written = _zoned_adf("Asia/Tokyo").export_partitioned(tmp_path, ByTime("timestamp", every="1d"))
     predicted = SaveAs.expected_paths(
         "time:timestamp+daily:%Y-%m-%d",
-        start=dt.datetime(2026, 1, 1, tzinfo=dt.UTC),
-        end=dt.datetime(2026, 1, 1, 23, 59, tzinfo=dt.UTC),
+        start=dt.datetime(2026, 1, 1, tzinfo=dt.timezone.utc),
+        end=dt.datetime(2026, 1, 1, 23, 59, tzinfo=dt.timezone.utc),
     )
 
     assert [p.name for p in predicted] == ["2026-01-01.parquet"]
@@ -432,3 +432,34 @@ def test_export_partitioned_suffix_is_configurable(timeseries_adf, tmp_path):
     # the default is unchanged, and the files stay readable whatever they are called
     written = timeseries_adf.export_partitioned(tmp_path / "default", ByColumn("mmsi"))
     assert sorted(p.name for p in written) == ["mmsi_1.parquet", "mmsi_2.parquet", "mmsi_3.parquet"]
+
+
+def test_by_time_time_zone_converts_before_truncating(tmp_path, caplog):
+    """`time_zone` decides which day an instant belongs to, whatever the column carries."""
+    tokyo = _zoned_adf("Asia/Tokyo")
+
+    # the column's own zone (default): Tokyo days
+    assert [p.name for p in tokyo.export_partitioned(tmp_path / "own", ByTime("timestamp", every="1d"))] == [
+        "2026-01-02.parquet"
+    ]
+    # converted to UTC: the same instants are a UTC 1 Jan
+    caplog.clear()  # the default export above warned - that is its own test
+    with caplog.at_level("WARNING", logger="damast.core.partitioning"):
+        written = tokyo.export_partitioned(tmp_path / "utc", ByTime("timestamp", every="1d", time_zone="UTC"))
+    assert [p.name for p in written] == ["2026-01-01.parquet"]
+    assert caplog.records == []
+
+    # a naive column is read as UTC, so converting it to UTC changes nothing
+    assert [p.name for p in _zoned_adf(None).export_partitioned(
+        tmp_path / "naive", ByTime("timestamp", every="1d", time_zone="UTC"))] == ["2026-01-01.parquet"]
+
+
+def test_by_time_explicit_local_time_zone_is_not_warned_about(tmp_path, caplog):
+    """Deliberately bucketing by local days is legitimate - only an accidental one warns."""
+    with caplog.at_level("WARNING", logger="damast.core.partitioning"):
+        written = _zoned_adf("UTC").export_partitioned(
+            tmp_path, ByTime("timestamp", every="1d", time_zone="Asia/Tokyo")
+        )
+
+    assert [p.name for p in written] == ["2026-01-02.parquet"]
+    assert caplog.records == []