feat: plumb Dataset start/end times through graphQL

app/relay.config.js

@@ -7,5 +7,6 @@ module.exports = {
   noFutureProofEnums: true,
   customScalars: {
     GlobalID: "String",
+    "DateTime": "string",
   },
 };

app/schema.graphql

@@ -1,5 +1,10 @@
+"""Date with time (isoformat)"""
+scalar DateTime
+
 type Dataset {
   name: String!
+  startTime: DateTime!
+  endTime: DateTime!
 }
 
 type Dimension implements Node {

app/src/App.tsx

@@ -18,9 +18,13 @@ const RootQuery = graphql`
   query AppRootQuery {
     primaryDataset {
       name
+      startTime
+      endTime
     }
     referenceDataset {
       name
+      startTime
+      endTime
     }
   }
 `;

src/phoenix/datasets/dataset.py

@@ -4,7 +4,8 @@
 import uuid
 from copy import deepcopy
 from dataclasses import fields, replace
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Set, Tuple, Union, cast
 
 from pandas import DataFrame, Series, Timestamp, read_parquet, to_datetime
 from pandas.api.types import is_numeric_dtype
@@ -72,6 +73,20 @@ def __init__(
         self.to_disc()
         logger.info(f"""Dataset: {self.__name} initialized""")
 
+    @property
+    def start_time(self) -> datetime:
+        """Returns the datetime of the earliest inference in the dataset"""
+        ts_col_name: str = cast(str, self.schema.timestamp_column_name)
+        dt: datetime = self.__dataframe[ts_col_name].min()
+        return dt
+
+    @property
+    def end_time(self) -> datetime:
+        """Returns the datetime of the latest inference in the dataset"""
+        ts_col_name: str = cast(str, self.schema.timestamp_column_name)
+        dt: datetime = self.__dataframe[ts_col_name].max()
+        return dt
+
     @property
     def dataframe(self) -> DataFrame:
         return self.__dataframe

src/phoenix/server/api/schema.py

@@ -2,7 +2,7 @@
 from strawberry.types import Info
 
 from .context import Context
-from .types.Dataset import Dataset
+from .types.Dataset import Dataset, to_gql_dataset
 from .types.Dimension import to_gql_dimension
 from .types.EmbeddingDimension import to_gql_embedding_dimension
 from .types.Model import Model
@@ -13,11 +13,11 @@
 class Query:
     @strawberry.field
     def primary_dataset(self, info: Info[Context, None]) -> Dataset:
-        return Dataset(name=info.context.model.primary_dataset.name)
+        return to_gql_dataset(info.context.model.primary_dataset)
 
     @strawberry.field
     def reference_dataset(self, info: Info[Context, None]) -> Dataset:
-        return Dataset(name=info.context.model.reference_dataset.name)
+        return to_gql_dataset(info.context.model.reference_dataset)
 
     @strawberry.field
     def model(self) -> Model:

src/phoenix/server/api/types/Dataset.py

@@ -1,6 +1,23 @@
+from datetime import datetime
+
 import strawberry
 
+from phoenix.datasets import Dataset as InternalDataset
+
 
 @strawberry.type
 class Dataset:
     name: str
+    start_time: datetime
+    end_time: datetime
+
+
+def to_gql_dataset(dataset: InternalDataset) -> Dataset:
+    """
+    Converts a phoenix.datasets.Dataset to a phoenix.server.api.types.Dataset
+    """
+    return Dataset(
+        name=dataset.name,
+        start_time=dataset.start_time,
+        end_time=dataset.end_time,
+    )

tests/datasets/test_dataset.py

@@ -801,6 +801,29 @@ def test_dataset_validate_invalid_schema_excludes_prediction_id(self) -> None:
         with raises(DatasetError):
             Dataset(dataframe=input_df, schema=input_schema)
 
+    def test_dataset_bookends(self) -> None:
+        expected_start_time = pd.Timestamp(year=2023, month=1, day=1, hour=2, second=30)
+        expected_end_time = pd.Timestamp(year=2023, month=1, day=10, hour=6, second=20)
+        input_df = DataFrame(
+            {
+                "prediction_label": ["apple", "orange", "grape"],
+                "timestamp": [
+                    expected_end_time,
+                    expected_start_time,
+                    pd.Timestamp(year=2023, month=1, day=5, hour=4, second=25),
+                ],
+            }
+        )
+
+        input_schema = Schema(
+            prediction_label_column_name="prediction_label",
+            timestamp_column_name="timestamp",
+        )
+        output_dataset = Dataset(dataframe=input_df, schema=input_schema)
+
+        assert output_dataset.start_time == expected_start_time
+        assert output_dataset.end_time == expected_end_time
+
     @property
     def num_records(self):
         return self._NUM_RECORDS

tests/server/api/types/test_dataset.py

@@ -0,0 +1,34 @@
+import pytest
+from pandas import DataFrame, Timestamp
+
+from phoenix.datasets import Dataset as InputDataset
+from phoenix.datasets import Schema
+from phoenix.server.api.types import Dataset
+
+
+@pytest.fixture
+def input_dataset():
+    input_df = DataFrame(
+        {
+            "prediction_label": ["apple", "orange", "grape"],
+            "timestamp": [
+                Timestamp(year=2023, month=1, day=1, hour=2, second=30),
+                Timestamp(year=2023, month=1, day=5, hour=4, second=25),
+                Timestamp(year=2023, month=1, day=10, hour=6, second=20),
+            ],
+        }
+    )
+
+    input_schema = Schema(
+        prediction_label_column_name="prediction_label",
+        timestamp_column_name="timestamp",
+    )
+    return InputDataset(dataframe=input_df, schema=input_schema)
+
+
+def test_dataset_serialization(input_dataset):
+    converted_gql_dataset = Dataset.to_gql_dataset(input_dataset)
+
+    expected_dataset = input_dataset
+    assert converted_gql_dataset.start_time == expected_dataset.start_time
+    assert converted_gql_dataset.end_time == expected_dataset.end_time