scistackplotdb 0.1.53__tar.gz → 0.1.56__tar.gz

{scistackplotdb-0.1.53 → scistackplotdb-0.1.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scistackplotdb
-Version: 0.1.53
+Version: 0.1.56
 Summary: scidb-backed plotting: load variables into long tables and plot them with scistackplot
 Author: SciStack Contributors
 License-Expression: MIT
@@ -17,10 +17,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: sciduckdb==0.1.53
-Requires-Dist: scistack-db==0.1.53
-Requires-Dist: scistacklog==0.1.53
-Requires-Dist: scistackplot==0.1.53
+Requires-Dist: sciduckdb==0.1.56
+Requires-Dist: scistack-db==0.1.56
+Requires-Dist: scistacklog==0.1.56
+Requires-Dist: scistackplot==0.1.56
 Provides-Extra: dev
 Requires-Dist: matplotlib>=3.6; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'

{scistackplotdb-0.1.53 → scistackplotdb-0.1.56}/src/scistackplotdb/load.py

@@ -21,6 +21,7 @@ from typing import Any
 
 import numpy as np
 import pandas as pd
+from sciduckdb import merge_tz_columns, stored_tz_companions, tz_column_name
 from scistacklog import Log
 from scistackplot import CODE_FACTOR_PREFIX, RUN_FACTOR_PREFIX
 from scistackplot.framesize import format_extent, frame_extent
@@ -130,6 +131,41 @@ def data_columns_for(db, variable: str) -> list[str]:
     return list(data_column_types_for(db, variable))
 
 
+def _stored_column_types(db, variable: str) -> dict[str, str]:
+    """``{column: DuckDB type}`` of the variable's table as stored (zone
+    companions included), in ordinal order."""
+    table = table_name_for(db, variable)
+    rows = db._duck._fetchall(
+        "SELECT column_name, data_type FROM information_schema.columns "
+        "WHERE table_name = ? AND column_name != 'record_id' "
+        "ORDER BY ordinal_position",
+        [table],
+    )
+    return {row[0]: str(row[1] or "") for row in rows}
+
+
+def datetime_zone_meta(db, variable: str, columns) -> dict:
+    """The dtype metadata ``sciduckdb.merge_tz_columns`` needs to fold the
+    ``__tz`` zone column of each datetime column in ``columns`` back in:
+    ``{"columns": {col: {"python_type": "datetime", "unit": ...}}}``. The
+    unit comes from the variable's stored metadata; the companion is found
+    in the table schema (owner ``sciduckdb.stored_tz_companions``)."""
+    zone_cols = stored_tz_companions(_stored_column_types(db, variable))
+    sources = [src for src in zone_cols.values() if src in set(columns)]
+    if not sources:
+        return {"columns": {}}
+    stored = (db.get_dtype_meta(variable) or {}).get("columns", {})
+    return {
+        "columns": {
+            src: {
+                **{"python_type": "datetime"},
+                **{k: v for k, v in (stored.get(src) or {}).items() if k == "unit"},
+            }
+            for src in sources
+        }
+    }
+
+
 def data_column_types_for(db, variable: str) -> dict[str, str]:
     """``{column: declared DuckDB type}``, in ordinal order.
 
@@ -139,13 +175,7 @@ def data_column_types_for(db, variable: str) -> dict[str, str]:
     (:func:`is_container_type`). It never accepts one; see that function.
     """
     table = table_name_for(db, variable)
-    rows = db._duck._fetchall(
-        "SELECT column_name, data_type FROM information_schema.columns "
-        "WHERE table_name = ? AND column_name != 'record_id' "
-        "ORDER BY ordinal_position",
-        [table],
-    )
-    types = {row[0]: str(row[1] or "") for row in rows}
+    types = _stored_column_types(db, variable)
 
     # A data column named after a schema key is an address stored as payload:
     # a record saved before the spread/collision rules stripped such columns
@@ -171,6 +201,18 @@ def data_column_types_for(db, variable: str) -> dict[str, str]:
         )
         for name in shadowed:
             del types[name]
+
+    # A datetime column's __tz zone companion is storage, not a column to
+    # plot (owner sciduckdb.datetimes). load_variable selects it anyway and
+    # folds it back into its datetime column (datetime_zone_meta).
+    zone_cols = stored_tz_companions(types)
+    if zone_cols:
+        Log.debug(
+            "variable %r: datetime zone column(s) %s left out of the data columns",
+            variable, sorted(zone_cols), layer=LAYER,
+        )
+        for name in zone_cols:
+            del types[name]
     return types
 
 
@@ -442,7 +484,12 @@ def load_variable(
         schema_select = "".join(
             f', CAST(s."{key}" AS VARCHAR) AS "{key}"' for key in keys
         )
-        data_select = "".join(f', t."{column}"' for column in columns)
+        # Datetime columns bring their __tz zone column, folded back right
+        # after the fetch (sciduckdb.merge_tz_columns): without it every
+        # aware value reached a plot as a naive UTC instant.
+        zone_meta = datetime_zone_meta(db, variable, columns) if columns else {"columns": {}}
+        zone_select = [tz_column_name(c) for c in zone_meta["columns"]]
+        data_select = "".join(f', t."{column}"' for column in [*columns, *zone_select])
         query = (
             f"SELECT t.record_id{data_select}{schema_select} "
             f'FROM "{table}" t '
@@ -464,6 +511,9 @@ def load_variable(
         # regression to per-sample boxing is visible in the log, not inferred.
         with timer.phase("fetch"):
             frame = db._duck._fetchdf(query, [variable])
+        if zone_meta["columns"]:
+            with timer.phase("datetime_zones"):
+                merge_tz_columns(frame, zone_meta, where=f"load_variable({variable})")
 
         with timer.phase("dataframe"):
             frame = frame[["record_id", *columns, *keys]].copy()

{scistackplotdb-0.1.53 → scistackplotdb-0.1.56}/src/scistackplotdb/source.py

@@ -28,6 +28,7 @@ from scistackplot.dedup import SingleFlight
 from scistackplot.framesize import format_extent, frame_extent
 from scistackplot.sources import BaseSource, UnknownMeasureError
 from scistackplot.variants import VARIABLE_COLUMN
+from scistackplot.temporal import is_temporal_column
 
 from .hierarchy import join_frames, joinable, joined_levels
 from .load import (
@@ -75,7 +76,16 @@ def _as_levels(column):
     synthetic-factors invariant 4 exists to prevent. The order matters:
     ``astype(str)`` first would turn every missing value into the string
     ``"nan"``.
+
+    A DATETIME column is the exception: its values stay datetimes (missing
+    ones named), and ``LongTable.from_frame`` gives each its identity label
+    in time order (``scistackplot.temporal.level_labels``) — text that says
+    when, not ``2026-07-01 14:00:00+02:00`` sorted as text. The generated code
+    emits the same labels (``temporal.factor_label_code``).
     """
+    if is_temporal_column(column):
+        out = column.astype(object).where(column.notna(), MISSING_LEVEL)
+        return out
     return column.fillna(MISSING_LEVEL).astype(str)
 
 
@@ -1380,6 +1390,20 @@ class ScidbSource(BaseSource):
                 usable.append(column)
             else:
                 skipped.append(column)
+        # Datetime fields melt into ONE value column with the rest, which is a
+        # time axis only if every field is a datetime (scistackplot.temporal).
+        # Beside numeric fields they would read as numbers (NaN), so they are
+        # left out and named — group by one (Variable.column) instead.
+        datetimes = [c for c in usable if is_temporal_column(frame[c])]
+        if datetimes and len(datetimes) < len(usable):
+            Log.warn(
+                "variable %r: datetime field(s) %s cannot share one axis with its "
+                "numeric field(s) and were left out — group by one instead",
+                variable_frame.name,
+                datetimes,
+                layer=LAYER,
+            )
+            usable = [c for c in usable if c not in datetimes]
         if skipped:
             Log.warn(
                 "variable %r: %d field(s) are not plottable and were dropped: %s",