test: cover datetime unit inference (#905)

* test: cover datetime unit inference

* test: add datetime unit variants

* test: expand datetime unit coverage

* docs: note datetime unit tests

Author: lmeyerov

CHANGELOG.md

@@ -8,6 +8,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ## [Development]
 <!-- Do Not Erase This Section - Used for tracking unreleased changes -->
 
+### Tests
+- **Temporal**: Added datetime unit parity coverage (ms/us/ns) for ring layouts, GFQL time ring layouts, and temporal comparison predicates; relaxed honeypot hypergraph datetime unit expectations.
+
 ## [0.50.5 - 2026-01-25]
 
 ### Fixed

graphistry/tests/compute/gfql/layouts/test_call_layout_radial.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pandas as pd
 import pytest
 
@@ -56,6 +57,24 @@ def _graph_with_time(self):
             .nodes(nodes)\
             .bind(source='source', destination='target', node='node')
 
+    def _graph_with_time_unit(self, unit: str):
+        edges = pd.DataFrame({
+            'source': [0, 1, 2],
+            'target': [1, 2, 0]
+        })
+        nodes = pd.DataFrame({
+            'node': [0, 1, 2],
+            'ts': pd.to_datetime([
+                '2024-01-01T00:00:00',
+                '2024-01-01T00:01:00',
+                '2024-01-01T00:02:00'
+            ]).astype(f'datetime64[{unit}]')
+        })
+        return CGFull()\
+            .edges(edges)\
+            .nodes(nodes)\
+            .bind(source='source', destination='target', node='node')
+
     def test_continuous_mode_basic(self):
         """Continuous mode should bind coordinates from a numeric column."""
         g = self._graph_with_numeric()
@@ -132,6 +151,39 @@ def test_time_mode_iso_strings(self):
 
         assert {'x', 'y', 'r'} <= set(result._nodes.columns)
 
+    @pytest.mark.parametrize('unit', ['us', 'ms'])
+    def test_time_mode_unit_parity(self, unit):
+        g_ns = self._graph_with_time_unit('ns')
+        g_unit = self._graph_with_time_unit(unit)
+
+        result_ns = execute_call(
+            g_ns,
+            'time_ring_layout',
+            {
+                'time_col': 'ts',
+                'time_start': '2024-01-01T00:00:00',
+                'time_end': '2024-01-01T00:02:00',
+                'num_rings': 3
+            },
+            Engine.PANDAS
+        )
+        result_unit = execute_call(
+            g_unit,
+            'time_ring_layout',
+            {
+                'time_col': 'ts',
+                'time_start': '2024-01-01T00:00:00',
+                'time_end': '2024-01-01T00:02:00',
+                'num_rings': 3
+            },
+            Engine.PANDAS
+        )
+
+        np.testing.assert_allclose(
+            result_ns._nodes['r'].to_numpy(),
+            result_unit._nodes['r'].to_numpy()
+        )
+
     def test_time_mode_invalid_strings_raise(self):
         """Time mode should raise when time bounds are invalid strings."""
         g = self._graph_with_time()

graphistry/tests/compute/predicates/test_temporal_values.py

@@ -5,7 +5,7 @@
 from graphistry.compute.ast_temporal import (
     DateTimeValue, DateValue, TimeValue, temporal_value_from_json
 )
-from graphistry.compute.predicates.comparison import gt
+from graphistry.compute.predicates.comparison import gt, lt, le, ge, eq, ne
 from graphistry.embed_utils import check_cudf
 
 
@@ -127,6 +127,34 @@ def test_gt_localizes_naive_series(self):
         expected = pd.Series([False, True])
         pd.testing.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize("unit", ["us", "ms"])
+    def test_gt_naive_series_unit_variants(self, unit):
+        s = pd.Series(pd.to_datetime(["2024-01-01 05:00:00", "2024-01-01 08:00:00"]))
+        s = s.astype(f"datetime64[{unit}]")
+        predicate = gt(DateTimeValue("2024-01-01T06:00:00", "UTC"))
+        result = predicate(s)
+        expected = pd.Series([False, True])
+        pd.testing.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["us", "ms"])
+    @pytest.mark.parametrize(
+        "predicate_factory, expected",
+        [
+            (lt, [True, False]),
+            (le, [True, False]),
+            (ge, [False, True]),
+            (eq, [False, False]),
+            (ne, [True, True]),
+        ],
+    )
+    def test_comparison_unit_variants(self, unit, predicate_factory, expected):
+        s = pd.Series(pd.to_datetime(["2024-01-01 05:00:00", "2024-01-01 08:00:00"]))
+        s = s.astype(f"datetime64[{unit}]")
+        predicate = predicate_factory(DateTimeValue("2024-01-01T06:00:00", "UTC"))
+        result = predicate(s)
+        expected_series = pd.Series(expected)
+        pd.testing.assert_series_equal(result, expected_series)
+
     def test_gt_converts_timezone_aware_series(self):
         s = pd.Series(pd.to_datetime(["2024-01-01 12:00:00", "2024-01-01 14:00:00"], utc=True))
         predicate = gt(DateTimeValue("2024-01-01T08:00:00", "US/Eastern"))

graphistry/tests/layout/ring/test_time.py

@@ -292,14 +292,21 @@ def test_ring_pd_us_ns_equivalence(self):
             })
             nodes_us = nodes.copy()
             nodes_us['t'] = nodes_us['t'].astype('datetime64[us]')
+            nodes_ms = nodes.copy()
+            nodes_ms['t'] = nodes_ms['t'].astype('datetime64[ms]')
 
             g_ns = lg.edges(edges, 's', 'd').nodes(nodes).time_ring_layout('t')
             g_us = lg.edges(edges, 's', 'd').nodes(nodes_us).time_ring_layout('t')
+            g_ms = lg.edges(edges, 's', 'd').nodes(nodes_ms).time_ring_layout('t')
 
         np.testing.assert_allclose(
             g_ns._nodes['r'].to_numpy(),
             g_us._nodes['r'].to_numpy()
         )
+        np.testing.assert_allclose(
+            g_ns._nodes['r'].to_numpy(),
+            g_ms._nodes['r'].to_numpy()
+        )
 
 
     def test_ring_pd_axis_positions(self):

graphistry/tests/test_hyper_dask.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import datetime as dt, logging, numpy as np, os, pandas as pd, pyarrow as pa, pytest
+from pandas.api.types import is_datetime64_any_dtype
 
 from graphistry.pygraphistry import PyGraphistry
 from graphistry.Engine import Engine, DataframeLike
@@ -61,19 +62,18 @@ def honeypot_pdf() -> pd.DataFrame:
         "time(max)": "float64",
         "time(min)": "float64",
     }
-    base_dtypes = {
-        **base_csv_dtypes,
-        "time(max)": "datetime64[ns]",
-        "time(min)": "datetime64[ns]",
-    }
     df = pd.read_csv(
         "graphistry/tests/data/honeypot.5.csv",
         #'graphistry/tests/data/honeypot.csv',
         dtype=base_csv_dtypes,
         parse_dates=["time(max)", "time(min)"],
         date_parser=lambda v: pd.to_datetime(int(float(v))),
     )
-    assert df.dtypes.to_dict() == base_dtypes
+    dtypes = df.dtypes.to_dict()
+    for col, dtype in base_csv_dtypes.items():
+        assert dtypes[col] == dtype
+    for col in ("time(max)", "time(min)"):
+        assert is_datetime64_any_dtype(dtypes[col])
     assert len(df) == HONEYPOT_ROWS
     return df
 
@@ -537,6 +537,23 @@ def test_hyper_to_pa_mixed2(self):
         nodes_arr = pa.Table.from_pandas(hg.graph._nodes)
         assert len(nodes_arr) == HONEYPOT_NODES
 
+    @pytest.mark.parametrize("unit", ["ms", "us"])
+    def test_hyper_to_pa_mixed2_unit_variants(self, unit):
+        df = honeypot_pdf().copy()
+        for col in ("time(max)", "time(min)"):
+            df[col] = df[col].astype(f"datetime64[{unit}]")
+
+        hg = hypergraph(**honeypot_hyperparams(df))
+
+        for col in ("time(max)", "time(min)"):
+            assert is_datetime64_any_dtype(hg.graph._edges.dtypes[col])
+            assert is_datetime64_any_dtype(hg.graph._nodes.dtypes[col])
+
+        edges_arr = pa.Table.from_pandas(hg.graph._edges)
+        assert len(edges_arr) == HONEYPOT_EDGES
+        nodes_arr = pa.Table.from_pandas(hg.graph._nodes)
+        assert len(nodes_arr) == HONEYPOT_NODES
+
     def test_hyper_to_pa_na(self):
 
         df = pd.DataFrame({"x": ["a", None, "c"], "y": [1, 2, None]})