arize-phoenix 8.32.0__py3-none-any.whl → 9.0.0__py3-none-any.whl

phoenix/server/api/types/ProjectTraceRetentionPolicy.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Annotated, Optional, Union
+
+import strawberry
+from strawberry import UNSET, Private
+from strawberry.relay import Connection, Node, NodeID
+from strawberry.types import Info
+from typing_extensions import TypeAlias, assert_never
+
+from phoenix.db import models
+from phoenix.db.types.trace_retention import MaxCountRule, MaxDaysOrCountRule, MaxDaysRule
+from phoenix.server.api.context import Context
+from phoenix.server.api.types.CronExpression import CronExpression
+from phoenix.server.api.types.pagination import ConnectionArgs, CursorString, connection_from_list
+from phoenix.server.api.types.Project import Project
+
+
+@strawberry.type
+class TraceRetentionRuleMaxDays:
+    max_days: float
+
+
+@strawberry.type
+class TraceRetentionRuleMaxCount:
+    max_count: int
+
+
+@strawberry.type
+class TraceRetentionRuleMaxDaysOrCount(TraceRetentionRuleMaxDays, TraceRetentionRuleMaxCount): ...
+
+
+TraceRetentionRule: TypeAlias = Annotated[
+    Union[TraceRetentionRuleMaxDays, TraceRetentionRuleMaxCount, TraceRetentionRuleMaxDaysOrCount],
+    strawberry.union("TraceRetentionRule"),
+]
+
+
+@strawberry.type
+class ProjectTraceRetentionPolicy(Node):
+    id: NodeID[int]
+    db_policy: Private[Optional[models.ProjectTraceRetentionPolicy]] = None
+
+    @strawberry.field
+    async def name(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_policy:
+            value = self.db_policy.name
+        else:
+            value = await info.context.data_loaders.project_trace_retention_policy_fields.load(
+                (self.id, models.ProjectTraceRetentionPolicy.name),
+            )
+        return value
+
+    @strawberry.field
+    async def cron_expression(
+        self,
+        info: Info[Context, None],
+    ) -> CronExpression:
+        if self.db_policy:
+            value = self.db_policy.cron_expression
+        else:
+            value = await info.context.data_loaders.project_trace_retention_policy_fields.load(
+                (self.id, models.ProjectTraceRetentionPolicy.cron_expression),
+            )
+        return CronExpression(value.root)
+
+    @strawberry.field
+    async def rule(
+        self,
+        info: Info[Context, None],
+    ) -> TraceRetentionRule:
+        if self.db_policy:
+            value = self.db_policy.rule
+        else:
+            value = await info.context.data_loaders.project_trace_retention_policy_fields.load(
+                (self.id, models.ProjectTraceRetentionPolicy.rule),
+            )
+        if isinstance(value.root, MaxDaysRule):
+            return TraceRetentionRuleMaxDays(max_days=value.root.max_days)
+        if isinstance(value.root, MaxCountRule):
+            return TraceRetentionRuleMaxCount(max_count=value.root.max_count)
+        if isinstance(value.root, MaxDaysOrCountRule):
+            return TraceRetentionRuleMaxDaysOrCount(
+                max_days=value.root.max_days, max_count=value.root.max_count
+            )
+        assert_never(value.root)
+
+    @strawberry.field
+    async def projects(
+        self,
+        info: Info[Context, None],
+        first: Optional[int] = 100,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection[Project]:
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
+        project_rowids = await info.context.data_loaders.projects_by_trace_retention_policy_id.load(
+            self.id
+        )
+        data = [Project(project_rowid=project_rowid) for project_rowid in project_rowids]
+        return connection_from_list(data=data, args=args)

phoenix/server/api/types/Span.py

@@ -1,11 +1,14 @@
 import json
 from asyncio import gather
+from collections import defaultdict
 from collections.abc import Mapping
+from dataclasses import asdict, dataclass
 from datetime import datetime
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Iterable, Optional, cast
 
 import numpy as np
+import pandas as pd
 import strawberry
 from openinference.semconv.trace import SpanAttributes
 from strawberry import ID, UNSET
@@ -21,10 +24,15 @@ from phoenix.server.api.helpers.dataset_helpers import (
     get_dataset_example_output,
 )
 from phoenix.server.api.input_types.InvocationParameters import InvocationParameter
+from phoenix.server.api.input_types.SpanAnnotationFilter import (
+    SpanAnnotationFilter,
+    satisfies_filter,
+)
 from phoenix.server.api.input_types.SpanAnnotationSort import (
     SpanAnnotationColumn,
     SpanAnnotationSort,
 )
+from phoenix.server.api.types.AnnotationSummary import AnnotationSummary
 from phoenix.server.api.types.DocumentRetrievalMetrics import DocumentRetrievalMetrics
 from phoenix.server.api.types.Evaluation import DocumentEvaluation
 from phoenix.server.api.types.ExampleRevisionInterface import ExampleRevision
@@ -490,11 +498,16 @@ class Span(Node):
         self,
         info: Info[Context, None],
         sort: Optional[SpanAnnotationSort] = UNSET,
+        filter: Optional[SpanAnnotationFilter] = None,
     ) -> list[SpanAnnotation]:
         span_id = self.span_rowid
         annotations = await info.context.data_loaders.span_annotations.load(span_id)
         sort_key = SpanAnnotationColumn.name.value
         sort_descending = False
+        if filter:
+            annotations = [
+                annotation for annotation in annotations if satisfies_filter(annotation, filter)
+            ]
         if sort:
             sort_key = sort.col.value
             sort_descending = sort.dir is SortDir.desc
@@ -503,6 +516,71 @@ class Span(Node):
         )
         return [to_gql_span_annotation(annotation) for annotation in annotations]
 
+    @strawberry.field(description=("Notes associated with the span."))  # type: ignore
+    async def span_notes(
+        self,
+        info: Info[Context, None],
+    ) -> list[SpanAnnotation]:
+        span_id = self.span_rowid
+        annotations = await info.context.data_loaders.span_annotations.load(span_id)
+        annotations = [annotation for annotation in annotations if annotation.name == "note"]
+        annotations.sort(key=lambda annotation: getattr(annotation, "created_at"), reverse=False)
+        return [to_gql_span_annotation(annotation) for annotation in annotations]
+
+    @strawberry.field(description="Summarizes each annotation (by name) associated with the span")  # type: ignore
+    async def span_annotation_summaries(
+        self,
+        info: Info[Context, None],
+        filter: Optional[SpanAnnotationFilter] = None,
+    ) -> list[AnnotationSummary]:
+        """
+        Retrieves and summarizes annotations associated with this span.
+
+        This method aggregates annotation data by name and label, calculating metrics
+        such as count of occurrences and sum of scores. The results are organized
+        into a structured format that can be easily converted to a DataFrame.
+
+        Args:
+            info: GraphQL context information
+            filter: Optional filter to apply to annotations before processing
+
+        Returns:
+            A list of AnnotationSummary objects, each containing:
+            - name: The name of the annotation
+            - data: A list of dictionaries with label statistics
+        """
+        # Load all annotations for this span from the data loader
+        annotations = await info.context.data_loaders.span_annotations.load(self.span_rowid)
+
+        # Apply filter if provided to narrow down the annotations
+        if filter:
+            annotations = [
+                annotation for annotation in annotations if satisfies_filter(annotation, filter)
+            ]
+
+        @dataclass
+        class Metrics:
+            record_count: int = 0
+            label_count: int = 0
+            score_sum: float = 0
+            score_count: int = 0
+
+        summaries: defaultdict[str, defaultdict[Optional[str], Metrics]] = defaultdict(
+            lambda: defaultdict(Metrics)
+        )
+        for annotation in annotations:
+            metrics = summaries[annotation.name][annotation.label]
+            metrics.record_count += 1
+            metrics.label_count += int(annotation.label is not None)
+            metrics.score_sum += annotation.score or 0
+            metrics.score_count += int(annotation.score is not None)
+
+        result: list[AnnotationSummary] = []
+        for name, label_metrics in summaries.items():
+            rows = [{"label": label, **asdict(metrics)} for label, metrics in label_metrics.items()]
+            result.append(AnnotationSummary(name=name, df=pd.DataFrame(rows), simple_avg=True))
+        return result
+
     @strawberry.field(
         description="Evaluations of the documents associated with the span, e.g. "
         "if the span is a RETRIEVER with a list of documents in its RETRIEVAL_DOCUMENTS "

phoenix/server/api/types/SpanAnnotation.py

@@ -4,19 +4,26 @@ import strawberry
 from strawberry import Private
 from strawberry.relay import GlobalID, Node, NodeID
 from strawberry.scalars import JSON
+from strawberry.types import Info
 
 from phoenix.db import models
+from phoenix.server.api.context import Context
 
 from .Annotation import Annotation
+from .AnnotationSource import AnnotationSource
 from .AnnotatorKind import AnnotatorKind
+from .User import User, to_gql_user
 
 
 @strawberry.type
 class SpanAnnotation(Node, Annotation):
     id_attr: NodeID[int]
+    user_id: Private[Optional[int]]
     annotator_kind: AnnotatorKind
     metadata: JSON
     span_rowid: Private[Optional[int]]
+    source: AnnotationSource
+    identifier: str
 
     @strawberry.field
     async def span_id(self) -> GlobalID:
@@ -24,6 +31,18 @@ class SpanAnnotation(Node, Annotation):
 
         return GlobalID(type_name=Span.__name__, node_id=str(self.span_rowid))
 
+    @strawberry.field
+    async def user(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[User]:
+        if self.user_id is None:
+            return None
+        user = await info.context.data_loaders.users.load(self.user_id)
+        if user is None:
+            return None
+        return to_gql_user(user)
+
 
 def to_gql_span_annotation(
     annotation: models.SpanAnnotation,
@@ -33,6 +52,7 @@ def to_gql_span_annotation(
     """
     return SpanAnnotation(
         id_attr=annotation.id,
+        user_id=annotation.user_id,
         span_rowid=annotation.span_rowid,
         name=annotation.name,
         annotator_kind=AnnotatorKind(annotation.annotator_kind),
@@ -40,4 +60,8 @@ def to_gql_span_annotation(
         score=annotation.score,
         explanation=annotation.explanation,
         metadata=annotation.metadata_,
+        source=AnnotationSource(annotation.source),
+        identifier=annotation.identifier,
+        created_at=annotation.created_at,
+        updated_at=annotation.updated_at,
     )

phoenix/server/api/types/Trace.py

@@ -208,13 +208,13 @@ class Trace(Node):
         return connection_from_list(data=data, args=args)
 
     @strawberry.field(description="Annotations associated with the trace.")  # type: ignore
-    async def span_annotations(
+    async def trace_annotations(
         self,
         info: Info[Context, None],
         sort: Optional[TraceAnnotationSort] = None,
     ) -> list[TraceAnnotation]:
         async with info.context.db() as session:
-            stmt = select(models.TraceAnnotation).filter_by(span_rowid=self.trace_rowid)
+            stmt = select(models.TraceAnnotation).filter_by(trace_rowid=self.trace_rowid)
             if sort:
                 sort_col = getattr(models.TraceAnnotation, sort.col.value)
                 if sort.dir is SortDir.desc:

phoenix/server/api/types/TraceAnnotation.py

@@ -4,14 +4,20 @@ import strawberry
 from strawberry import Private
 from strawberry.relay import GlobalID, Node, NodeID
 from strawberry.scalars import JSON
+from strawberry.types import Info
 
 from phoenix.db import models
+from phoenix.server.api.context import Context
 from phoenix.server.api.types.AnnotatorKind import AnnotatorKind
 
+from .AnnotationSource import AnnotationSource
+from .User import User, to_gql_user
+
 
 @strawberry.type
 class TraceAnnotation(Node):
     id_attr: NodeID[int]
+    user_id: Private[Optional[int]]
     name: str
     annotator_kind: AnnotatorKind
     label: Optional[str]
@@ -19,6 +25,8 @@ class TraceAnnotation(Node):
     explanation: Optional[str]
     metadata: JSON
     trace_rowid: Private[Optional[int]]
+    identifier: str
+    source: AnnotationSource
 
     @strawberry.field
     async def trace_id(self) -> GlobalID:
@@ -26,6 +34,18 @@ class TraceAnnotation(Node):
 
         return GlobalID(type_name=Trace.__name__, node_id=str(self.trace_rowid))
 
+    @strawberry.field
+    async def user(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[User]:
+        if self.user_id is None:
+            return None
+        user = await info.context.data_loaders.users.load(self.user_id)
+        if user is None:
+            return None
+        return to_gql_user(user)
+
 
 def to_gql_trace_annotation(
     annotation: models.TraceAnnotation,
@@ -35,6 +55,7 @@ def to_gql_trace_annotation(
     """
     return TraceAnnotation(
         id_attr=annotation.id,
+        user_id=annotation.user_id,
         trace_rowid=annotation.trace_rowid,
         name=annotation.name,
         annotator_kind=AnnotatorKind(annotation.annotator_kind),
@@ -42,4 +63,6 @@ def to_gql_trace_annotation(
         score=annotation.score,
         explanation=annotation.explanation,
         metadata=annotation.metadata_,
+        identifier=annotation.identifier,
+        source=AnnotationSource(annotation.source),
     )

phoenix/server/app.py

@@ -88,6 +88,7 @@ from phoenix.server.api.dataloaders import (
     NumChildSpansDataLoader,
     NumSpansPerTraceDataLoader,
     ProjectByNameDataLoader,
+    ProjectIdsByTraceRetentionPolicyIdDataLoader,
     PromptVersionSequenceNumberDataLoader,
     RecordCountDataLoader,
     SessionIODataLoader,
@@ -103,6 +104,7 @@ from phoenix.server.api.dataloaders import (
     TableFieldsDataLoader,
     TokenCountDataLoader,
     TraceByTraceIdsDataLoader,
+    TraceRetentionPolicyIdByProjectIdDataLoader,
     TraceRootSpansDataLoader,
     UserRolesDataLoader,
     UsersDataLoader,
@@ -123,6 +125,7 @@ from phoenix.server.grpc_server import GrpcServer
 from phoenix.server.jwt_store import JwtStore
 from phoenix.server.middleware.gzip import GZipMiddleware
 from phoenix.server.oauth2 import OAuth2Clients
+from phoenix.server.retention import TraceDataSweeper
 from phoenix.server.telemetry import initialize_opentelemetry_tracer_provider
 from phoenix.server.types import (
     CanGetLastUpdatedAt,
@@ -475,6 +478,7 @@ def _lifespan(
     db: DbSessionFactory,
     bulk_inserter: BulkInserter,
     dml_event_handler: DmlEventHandler,
+    trace_data_sweeper: Optional[TraceDataSweeper],
     token_store: Optional[TokenStore] = None,
     tracer_provider: Optional["TracerProvider"] = None,
     enable_prometheus: bool = False,
@@ -507,6 +511,8 @@ def _lifespan(
             )
             await stack.enter_async_context(grpc_server)
             await stack.enter_async_context(dml_event_handler)
+            if trace_data_sweeper:
+                await stack.enter_async_context(trace_data_sweeper)
             if scaffolder_config:
                 scaffolder = Scaffolder(
                     config=scaffolder_config,
@@ -633,6 +639,9 @@ def create_graphql_router(
                 num_child_spans=NumChildSpansDataLoader(db),
                 num_spans_per_trace=NumSpansPerTraceDataLoader(db),
                 project_fields=TableFieldsDataLoader(db, models.Project),
+                projects_by_trace_retention_policy_id=ProjectIdsByTraceRetentionPolicyIdDataLoader(
+                    db
+                ),
                 prompt_version_sequence_number=PromptVersionSequenceNumberDataLoader(db),
                 record_counts=RecordCountDataLoader(
                     db,
@@ -656,6 +665,12 @@ def create_graphql_router(
                 ),
                 trace_by_trace_ids=TraceByTraceIdsDataLoader(db),
                 trace_fields=TableFieldsDataLoader(db, models.Trace),
+                trace_retention_policy_id_by_project_id=TraceRetentionPolicyIdByProjectIdDataLoader(
+                    db
+                ),
+                project_trace_retention_policy_fields=TableFieldsDataLoader(
+                    db, models.ProjectTraceRetentionPolicy
+                ),
                 trace_root_spans=TraceRootSpansDataLoader(db),
                 project_by_name=ProjectByNameDataLoader(db),
                 users=UsersDataLoader(db),
@@ -817,6 +832,10 @@ def create_app(
         cache_for_dataloaders=cache_for_dataloaders,
         last_updated_at=last_updated_at,
     )
+    trace_data_sweeper = TraceDataSweeper(
+        db=db,
+        dml_event_handler=dml_event_handler,
+    )
     bulk_inserter = bulk_inserter_factory(
         db,
         enable_prometheus=enable_prometheus,
@@ -874,6 +893,7 @@ def create_app(
             read_only=read_only,
             bulk_inserter=bulk_inserter,
             dml_event_handler=dml_event_handler,
+            trace_data_sweeper=trace_data_sweeper,
             token_store=token_store,
             tracer_provider=tracer_provider,
             enable_prometheus=enable_prometheus,

phoenix/server/retention.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from asyncio import create_task, gather, sleep
+from datetime import datetime, timedelta, timezone
+
+import sqlalchemy as sa
+from sqlalchemy.orm import selectinload
+
+from phoenix.db.constants import DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID
+from phoenix.db.models import Project, ProjectTraceRetentionPolicy
+from phoenix.server.dml_event import SpanDeleteEvent
+from phoenix.server.dml_event_handler import DmlEventHandler
+from phoenix.server.types import DaemonTask, DbSessionFactory
+from phoenix.utilities import hour_of_week
+
+
+class TraceDataSweeper(DaemonTask):
+    def __init__(self, db: DbSessionFactory, dml_event_handler: DmlEventHandler):
+        super().__init__()
+        self._db = db
+        self._dml_event_handler = dml_event_handler
+
+    async def _run(self) -> None:
+        """Check hourly and apply policies."""
+        while self._running:
+            await self._sleep_until_next_hour()
+            if not (policies := await self._get_policies()):
+                continue
+            current_hour = self._current_hour()
+            if tasks := [
+                create_task(self._apply(policy))
+                for policy in policies
+                if self._should_apply(policy, current_hour)
+            ]:
+                await gather(*tasks, return_exceptions=True)
+
+    async def _get_policies(self) -> list[ProjectTraceRetentionPolicy]:
+        stmt = sa.select(ProjectTraceRetentionPolicy).options(
+            selectinload(ProjectTraceRetentionPolicy.projects).load_only(Project.id)
+        )
+        async with self._db() as session:
+            result = await session.scalars(stmt)
+        # filter out no-op policies, e.g. max_days == 0
+        return [policy for policy in result if bool(policy.rule)]
+
+    @staticmethod
+    def _now() -> datetime:
+        return datetime.now(timezone.utc)
+
+    def _current_hour(self) -> int:
+        return hour_of_week(self._now())
+
+    def _should_apply(self, policy: ProjectTraceRetentionPolicy, current_hour: int) -> bool:
+        if current_hour != policy.cron_expression.get_hour_of_prev_run():
+            return False
+        if policy.id != DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID and not policy.projects:
+            return False
+        return True
+
+    async def _apply(self, policy: ProjectTraceRetentionPolicy) -> None:
+        project_rowids = (
+            (
+                sa.select(Project.id)
+                .where(Project.trace_retention_policy_id.is_(None))
+                .scalar_subquery()
+            )
+            if policy.id == DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID
+            else [p.id for p in policy.projects]
+        )
+        async with self._db() as session:
+            result = await policy.rule.delete_traces(session, project_rowids)
+        self._dml_event_handler.put(SpanDeleteEvent(tuple(result)))
+
+    async def _sleep_until_next_hour(self) -> None:
+        next_hour = self._now().replace(minute=0, second=0, microsecond=0) + timedelta(hours=1)
+        await sleep((next_hour - self._now()).total_seconds())

phoenix/server/static/.vite/manifest.json

@@ -1,28 +1,28 @@
 {
-  "_components-x-gKFJ8C.js": {
-    "file": "assets/components-x-gKFJ8C.js",
+  "_components-B2MWTXnm.js": {
+    "file": "assets/components-B2MWTXnm.js",
     "name": "components",
     "imports": [
-      "_vendor-BfhM_F1u.js",
-      "_pages-BU4VdyeH.js",
-      "_vendor-arizeai-CxXYQNUl.js",
-      "_vendor-codemirror-B0NIFPOL.js",
+      "_vendor-BRDkBC5J.js",
+      "_pages-CZ2vKu8H.js",
+      "_vendor-arizeai-BvTqp_W8.js",
+      "_vendor-codemirror-COt9UfW7.js",
       "_vendor-three-C5WAXd5r.js"
     ]
   },
-  "_pages-BU4VdyeH.js": {
-    "file": "assets/pages-BU4VdyeH.js",
+  "_pages-CZ2vKu8H.js": {
+    "file": "assets/pages-CZ2vKu8H.js",
     "name": "pages",
     "imports": [
-      "_vendor-BfhM_F1u.js",
-      "_vendor-arizeai-CxXYQNUl.js",
-      "_components-x-gKFJ8C.js",
-      "_vendor-codemirror-B0NIFPOL.js",
-      "_vendor-recharts-CrrDFWK1.js"
+      "_vendor-BRDkBC5J.js",
+      "_vendor-arizeai-BvTqp_W8.js",
+      "_components-B2MWTXnm.js",
+      "_vendor-codemirror-COt9UfW7.js",
+      "_vendor-recharts-BoHX9Hvs.js"
     ]
   },
-  "_vendor-BfhM_F1u.js": {
-    "file": "assets/vendor-BfhM_F1u.js",
+  "_vendor-BRDkBC5J.js": {
+    "file": "assets/vendor-BRDkBC5J.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-C5WAXd5r.js"
@@ -35,33 +35,33 @@
     "file": "assets/vendor-Cg6lcjUC.css",
     "src": "_vendor-Cg6lcjUC.css"
   },
-  "_vendor-arizeai-CxXYQNUl.js": {
-    "file": "assets/vendor-arizeai-CxXYQNUl.js",
+  "_vendor-arizeai-BvTqp_W8.js": {
+    "file": "assets/vendor-arizeai-BvTqp_W8.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-BfhM_F1u.js"
+      "_vendor-BRDkBC5J.js"
     ]
   },
-  "_vendor-codemirror-B0NIFPOL.js": {
-    "file": "assets/vendor-codemirror-B0NIFPOL.js",
+  "_vendor-codemirror-COt9UfW7.js": {
+    "file": "assets/vendor-codemirror-COt9UfW7.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-BfhM_F1u.js",
-      "_vendor-shiki-C5bJ-RPf.js"
+      "_vendor-BRDkBC5J.js",
+      "_vendor-shiki-Cw1dsDAz.js"
     ]
   },
-  "_vendor-recharts-CrrDFWK1.js": {
-    "file": "assets/vendor-recharts-CrrDFWK1.js",
+  "_vendor-recharts-BoHX9Hvs.js": {
+    "file": "assets/vendor-recharts-BoHX9Hvs.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-BfhM_F1u.js"
+      "_vendor-BRDkBC5J.js"
     ]
   },
-  "_vendor-shiki-C5bJ-RPf.js": {
-    "file": "assets/vendor-shiki-C5bJ-RPf.js",
+  "_vendor-shiki-Cw1dsDAz.js": {
+    "file": "assets/vendor-shiki-Cw1dsDAz.js",
     "name": "vendor-shiki",
     "imports": [
-      "_vendor-BfhM_F1u.js"
+      "_vendor-BRDkBC5J.js"
     ]
   },
   "_vendor-three-C5WAXd5r.js": {
@@ -69,19 +69,19 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-B0CbpsxD.js",
+    "file": "assets/index-Bfvpea_-.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-BfhM_F1u.js",
-      "_vendor-arizeai-CxXYQNUl.js",
-      "_pages-BU4VdyeH.js",
-      "_components-x-gKFJ8C.js",
+      "_vendor-BRDkBC5J.js",
+      "_vendor-arizeai-BvTqp_W8.js",
+      "_pages-CZ2vKu8H.js",
+      "_components-B2MWTXnm.js",
       "_vendor-three-C5WAXd5r.js",
-      "_vendor-codemirror-B0NIFPOL.js",
-      "_vendor-shiki-C5bJ-RPf.js",
-      "_vendor-recharts-CrrDFWK1.js"
+      "_vendor-codemirror-COt9UfW7.js",
+      "_vendor-shiki-Cw1dsDAz.js",
+      "_vendor-recharts-BoHX9Hvs.js"
     ]
   }
 }