arize-phoenix 12.6.1__py3-none-any.whl → 12.7.0__py3-none-any.whl

phoenix/server/api/routers/v1/datasets.py

@@ -23,6 +23,9 @@ from starlette.concurrency import run_in_threadpool
 from starlette.datastructures import FormData, UploadFile
 from starlette.requests import Request
 from starlette.responses import Response
+from starlette.status import (
+    HTTP_404_NOT_FOUND,
+)
 from strawberry.relay import GlobalID
 from typing_extensions import TypeAlias, assert_never
 
@@ -34,8 +37,10 @@ from phoenix.db.insertion.dataset import (
     ExampleContent,
     add_dataset_examples,
 )
+from phoenix.db.types.db_models import UNDEFINED
 from phoenix.server.api.types.Dataset import Dataset as DatasetNodeType
 from phoenix.server.api.types.DatasetExample import DatasetExample as DatasetExampleNodeType
+from phoenix.server.api.types.DatasetSplit import DatasetSplit as DatasetSplitNodeType
 from phoenix.server.api.types.DatasetVersion import DatasetVersion as DatasetVersionNodeType
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.utils import delete_projects, delete_traces
@@ -697,6 +702,7 @@ class DatasetExample(V1RoutesBaseModel):
 class ListDatasetExamplesData(V1RoutesBaseModel):
     dataset_id: str
     version_id: str
+    filtered_splits: list[str] = UNDEFINED
     examples: list[DatasetExample]
 
 
@@ -719,6 +725,10 @@ async def get_dataset_examples(
             "The ID of the dataset version (if omitted, returns data from the latest version)"
         ),
     ),
+    split: Optional[list[str]] = Query(
+        default=None,
+        description="List of dataset split identifiers (GlobalIDs or names) to filter by",
+    ),
 ) -> ListDatasetExamplesResponseBody:
     try:
         dataset_gid = GlobalID.from_id(id)
@@ -795,9 +805,13 @@ async def get_dataset_examples(
                 )
 
         subquery = partial_subquery.subquery()
+
         # Query for the most recent example revisions that are not deleted
         query = (
-            select(models.DatasetExample, models.DatasetExampleRevision)
+            select(
+                models.DatasetExample,
+                models.DatasetExampleRevision,
+            )
             .join(
                 models.DatasetExampleRevision,
                 models.DatasetExample.id == models.DatasetExampleRevision.dataset_example_id,
@@ -810,6 +824,28 @@ async def get_dataset_examples(
             .filter(models.DatasetExampleRevision.revision_kind != "DELETE")
             .order_by(models.DatasetExample.id.asc())
         )
+
+        # If splits are provided, filter by dataset splits
+        resolved_split_names: list[str] = []
+        if split:
+            # Resolve split identifiers (IDs or names) to IDs and names
+            resolved_split_ids, resolved_split_names = await _resolve_split_identifiers(
+                session, split
+            )
+
+            # Add filter for splits (join with the association table)
+            # Use distinct() to prevent duplicates when an example belongs to
+            # multiple splits
+            query = (
+                query.join(
+                    models.DatasetSplitDatasetExample,
+                    models.DatasetExample.id
+                    == models.DatasetSplitDatasetExample.dataset_example_id,
+                )
+                .filter(models.DatasetSplitDatasetExample.dataset_split_id.in_(resolved_split_ids))
+                .distinct()
+            )
+
         examples = [
             DatasetExample(
                 id=str(GlobalID("DatasetExample", str(example.id))),
@@ -824,6 +860,7 @@ async def get_dataset_examples(
         data=ListDatasetExamplesData(
             dataset_id=str(GlobalID("Dataset", str(resolved_dataset_id))),
             version_id=str(GlobalID("DatasetVersion", str(resolved_version_id))),
+            filtered_splits=resolved_split_names,
             examples=examples,
         )
     )
@@ -1080,3 +1117,115 @@ async def _get_db_examples(
 
 def _is_all_dict(seq: Sequence[Any]) -> bool:
     return all(map(lambda obj: isinstance(obj, dict), seq))
+
+
+# Split identifier helper types and functions
+class _SplitId(int): ...
+
+
+_SplitIdentifier: TypeAlias = Union[_SplitId, str]
+
+
+def _parse_split_identifier(split_identifier: str) -> _SplitIdentifier:
+    """
+    Parse a split identifier as either a GlobalID or a name.
+
+    Args:
+        split_identifier: The identifier string (GlobalID or name)
+
+    Returns:
+        Either a _SplitId or an Identifier
+
+    Raises:
+        HTTPException: If the identifier format is invalid
+    """
+    if not split_identifier:
+        raise HTTPException(422, "Invalid split identifier")
+    try:
+        split_id = from_global_id_with_expected_type(
+            GlobalID.from_id(split_identifier),
+            DatasetSplitNodeType.__name__,
+        )
+    except ValueError:
+        return split_identifier
+    return _SplitId(split_id)
+
+
+async def _resolve_split_identifiers(
+    session: AsyncSession,
+    split_identifiers: list[str],
+) -> tuple[list[int], list[str]]:
+    """
+    Resolve a list of split identifiers (IDs or names) to split IDs and names.
+
+    Args:
+        session: The database session
+        split_identifiers: List of split identifiers (GlobalIDs or names)
+
+    Returns:
+        Tuple of (list of split IDs, list of split names)
+
+    Raises:
+        HTTPException: If any split identifier is invalid or not found
+    """
+    split_ids: list[int] = []
+    split_names: list[str] = []
+
+    # Parse all identifiers first
+    parsed_identifiers: list[_SplitIdentifier] = []
+    for identifier_str in split_identifiers:
+        parsed_identifiers.append(_parse_split_identifier(identifier_str.strip()))
+
+    # Separate IDs and names
+    requested_ids: list[int] = []
+    requested_names: list[str] = []
+    for identifier in parsed_identifiers:
+        if isinstance(identifier, _SplitId):
+            requested_ids.append(int(identifier))
+        elif isinstance(identifier, str):
+            requested_names.append(identifier)
+        else:
+            assert_never(identifier)
+
+    # Query for splits by ID
+    if requested_ids:
+        id_results = await session.stream(
+            select(models.DatasetSplit.id, models.DatasetSplit.name).where(
+                models.DatasetSplit.id.in_(requested_ids)
+            )
+        )
+        async for split_id, split_name in id_results:
+            split_ids.append(split_id)
+            split_names.append(split_name)
+
+        # Check if all requested IDs were found
+        found_ids = set(split_ids[-len(requested_ids) :] if requested_ids else [])
+        missing_ids = [sid for sid in requested_ids if sid not in found_ids]
+        if missing_ids:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Dataset splits not found for IDs: {', '.join(map(str, missing_ids))}",
+            )
+
+    # Query for splits by name
+    if requested_names:
+        name_results = await session.stream(
+            select(models.DatasetSplit.id, models.DatasetSplit.name).where(
+                models.DatasetSplit.name.in_(requested_names)
+            )
+        )
+        name_to_id: dict[str, int] = {}
+        async for split_id, split_name in name_results:
+            split_ids.append(split_id)
+            split_names.append(split_name)
+            name_to_id[split_name] = split_id
+
+        # Check if all requested names were found
+        missing_names = [name for name in requested_names if name not in name_to_id]
+        if missing_names:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Dataset splits not found: {', '.join(missing_names)}",
+            )
+
+    return split_ids, split_names

phoenix/server/api/routers/v1/experiments.py

@@ -25,6 +25,7 @@ from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import ExperimentInsertEvent
 from phoenix.server.experiments.utils import generate_experiment_project_name
 
+from .datasets import _resolve_split_identifiers
 from .models import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses, add_text_csv_content_to_responses
 
@@ -80,6 +81,10 @@ class CreateExperimentRequestBody(V1RoutesBaseModel):
             "(if omitted, the latest version will be used)"
         ),
     )
+    splits: Optional[list[str]] = Field(
+        default=None,
+        description="List of dataset split identifiers (GlobalIDs or names) to filter by",
+    )
     repetitions: int = Field(
         default=1, description="Number of times the experiment should be repeated for each example"
     )
@@ -192,6 +197,20 @@ async def create_experiment(
             project_name=project_name,
             user_id=user_id,
         )
+
+        if request_body.splits is not None:
+            # Resolve split identifiers (IDs or names) to IDs and names
+            resolved_split_ids, _ = await _resolve_split_identifiers(session, request_body.splits)
+
+            # Generate experiment dataset splits relation
+            # prior to the crosswalk table insert
+            # in insert_experiment_with_examples_snapshot
+            experiment.experiment_dataset_splits = [
+                models.ExperimentDatasetSplit(dataset_split_id=split_id)
+                for split_id in resolved_split_ids
+            ]
+
+        # crosswalk table assumes the relation is already present
         await insert_experiment_with_examples_snapshot(session, experiment)
 
         dialect = SupportedSQLDialect(session.bind.dialect.name)

phoenix/server/api/subscriptions.py

@@ -17,7 +17,7 @@ from typing import (
 import strawberry
 from openinference.instrumentation import safe_json_dumps
 from openinference.semconv.trace import SpanAttributes
-from sqlalchemy import and_, func, insert, select
+from sqlalchemy import and_, insert, select
 from sqlalchemy.orm import load_only
 from strawberry.relay.types import GlobalID
 from strawberry.types import Info
@@ -26,7 +26,10 @@ from typing_extensions import TypeAlias, assert_never
 from phoenix.config import PLAYGROUND_PROJECT_NAME
 from phoenix.datetime_utils import local_now, normalize_datetime
 from phoenix.db import models
-from phoenix.db.helpers import insert_experiment_with_examples_snapshot
+from phoenix.db.helpers import (
+    get_dataset_example_revisions,
+    insert_experiment_with_examples_snapshot,
+)
 from phoenix.server.api.auth import IsLocked, IsNotReadOnly, IsNotViewer
 from phoenix.server.api.context import Context
 from phoenix.server.api.exceptions import BadRequest, CustomGraphQLError, NotFound
@@ -257,27 +260,22 @@ class Subscription:
                     )
                 ) is None:
                     raise NotFound(f"Could not find dataset version with ID {version_id}")
-            revision_ids = (
-                select(func.max(models.DatasetExampleRevision.id))
-                .join(models.DatasetExample)
-                .where(
-                    and_(
-                        models.DatasetExample.dataset_id == dataset_id,
-                        models.DatasetExampleRevision.dataset_version_id <= resolved_version_id,
-                    )
-                )
-                .group_by(models.DatasetExampleRevision.dataset_example_id)
-            )
+
+            # Parse split IDs if provided
+            resolved_split_ids: Optional[list[int]] = None
+            if input.split_ids is not None and len(input.split_ids) > 0:
+                resolved_split_ids = [
+                    from_global_id_with_expected_type(split_id, models.DatasetSplit.__name__)
+                    for split_id in input.split_ids
+                ]
+
             if not (
                 revisions := [
                     rev
                     async for rev in await session.stream_scalars(
-                        select(models.DatasetExampleRevision)
-                        .where(
-                            and_(
-                                models.DatasetExampleRevision.id.in_(revision_ids),
-                                models.DatasetExampleRevision.revision_kind != "DELETE",
-                            )
+                        get_dataset_example_revisions(
+                            resolved_version_id,
+                            split_ids=resolved_split_ids,
                         )
                         .order_by(models.DatasetExampleRevision.dataset_example_id.asc())
                         .options(
@@ -316,6 +314,11 @@ class Subscription:
                 project_name=project_name,
                 user_id=user_id,
             )
+            if resolved_split_ids:
+                experiment.experiment_dataset_splits = [
+                    models.ExperimentDatasetSplit(dataset_split_id=split_id)
+                    for split_id in resolved_split_ids
+                ]
             await insert_experiment_with_examples_snapshot(session, experiment)
         yield ChatCompletionSubscriptionExperiment(
             experiment=to_gql_experiment(experiment)

phoenix/server/api/types/Dataset.py

@@ -231,7 +231,7 @@ class Dataset(Node):
                     models.DatasetExampleRevision.revision_kind != "DELETE",
                 )
             )
-            .order_by(models.DatasetExampleRevision.dataset_example_id.desc())
+            .order_by(models.DatasetExample.id.desc())
         )
 
         # Filter by split IDs if provided

phoenix/server/api/types/Experiment.py

@@ -18,13 +18,16 @@ from phoenix.server.api.input_types.ExperimentRunSort import (
     get_experiment_run_cursor,
 )
 from phoenix.server.api.types.CostBreakdown import CostBreakdown
+from phoenix.server.api.types.DatasetSplit import DatasetSplit, to_gql_dataset_split
 from phoenix.server.api.types.DatasetVersion import DatasetVersion
 from phoenix.server.api.types.ExperimentAnnotationSummary import ExperimentAnnotationSummary
 from phoenix.server.api.types.ExperimentRun import ExperimentRun, to_gql_experiment_run
 from phoenix.server.api.types.pagination import (
+    ConnectionArgs,
     Cursor,
     CursorString,
     connection_from_cursors_and_nodes,
+    connection_from_list,
 )
 from phoenix.server.api.types.Project import Project
 from phoenix.server.api.types.SpanCostDetailSummaryEntry import SpanCostDetailSummaryEntry
@@ -228,6 +231,17 @@ class Experiment(Node):
                 async for token_type, is_prompt, cost, tokens in data
             ]
 
+    @strawberry.field
+    async def dataset_splits(
+        self,
+        info: Info[Context, None],
+    ) -> Connection[DatasetSplit]:
+        """Returns the dataset splits associated with this experiment."""
+        splits = await info.context.data_loaders.experiment_dataset_splits.load(self.id_attr)
+        return connection_from_list(
+            [to_gql_dataset_split(split) for split in splits], ConnectionArgs()
+        )
+
 
 def to_gql_experiment(
     experiment: models.Experiment,

phoenix/server/app.py

@@ -97,6 +97,7 @@ from phoenix.server.api.dataloaders import (
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
     ExperimentAnnotationSummaryDataLoader,
+    ExperimentDatasetSplitsDataLoader,
     ExperimentErrorRatesDataLoader,
     ExperimentRepeatedRunGroupAnnotationSummariesDataLoader,
     ExperimentRepeatedRunGroupsDataLoader,
@@ -735,6 +736,7 @@ def create_graphql_router(
                     ),
                 ),
                 experiment_annotation_summaries=ExperimentAnnotationSummaryDataLoader(db),
+                experiment_dataset_splits=ExperimentDatasetSplitsDataLoader(db),
                 experiment_error_rates=ExperimentErrorRatesDataLoader(db),
                 experiment_repeated_run_group_annotation_summaries=ExperimentRepeatedRunGroupAnnotationSummariesDataLoader(
                     db

phoenix/server/cost_tracking/model_cost_manifest.json

@@ -341,6 +341,60 @@
         }
       ]
     },
+    {
+      "name": "claude-haiku-4-5",
+      "name_pattern": "claude-haiku-4-5",
+      "source": "litellm",
+      "token_prices": [
+        {
+          "base_rate": 1e-6,
+          "is_prompt": true,
+          "token_type": "input"
+        },
+        {
+          "base_rate": 5e-6,
+          "is_prompt": false,
+          "token_type": "output"
+        },
+        {
+          "base_rate": 1e-7,
+          "is_prompt": true,
+          "token_type": "cache_read"
+        },
+        {
+          "base_rate": 1.25e-6,
+          "is_prompt": true,
+          "token_type": "cache_write"
+        }
+      ]
+    },
+    {
+      "name": "claude-haiku-4-5-20251001",
+      "name_pattern": "claude-haiku-4-5-20251001",
+      "source": "litellm",
+      "token_prices": [
+        {
+          "base_rate": 1e-6,
+          "is_prompt": true,
+          "token_type": "input"
+        },
+        {
+          "base_rate": 5e-6,
+          "is_prompt": false,
+          "token_type": "output"
+        },
+        {
+          "base_rate": 1e-7,
+          "is_prompt": true,
+          "token_type": "cache_read"
+        },
+        {
+          "base_rate": 1.25e-6,
+          "is_prompt": true,
+          "token_type": "cache_write"
+        }
+      ]
+    },
     {
       "name": "claude-opus-4-1",
       "name_pattern": "claude-opus-4-1",
@@ -741,6 +795,33 @@
         }
       ]
     },
+    {
+      "name": "gemini-2.5-flash-image",
+      "name_pattern": "gemini-2\\.5-flash-image",
+      "source": "litellm",
+      "token_prices": [
+        {
+          "base_rate": 3e-7,
+          "is_prompt": true,
+          "token_type": "input"
+        },
+        {
+          "base_rate": 2.5e-6,
+          "is_prompt": false,
+          "token_type": "output"
+        },
+        {
+          "base_rate": 3e-8,
+          "is_prompt": true,
+          "token_type": "cache_read"
+        },
+        {
+          "base_rate": 1e-6,
+          "is_prompt": true,
+          "token_type": "audio"
+        }
+      ]
+    },
     {
       "name": "gemini-2.5-flash-image-preview",
       "name_pattern": "gemini-2\\.5-flash-image-preview",
@@ -2465,6 +2546,40 @@
         }
       ]
     },
+    {
+      "name": "gpt-5-pro",
+      "name_pattern": "gpt-5-pro",
+      "source": "litellm",
+      "token_prices": [
+        {
+          "base_rate": 0.000015,
+          "is_prompt": true,
+          "token_type": "input"
+        },
+        {
+          "base_rate": 0.00012,
+          "is_prompt": false,
+          "token_type": "output"
+        }
+      ]
+    },
+    {
+      "name": "gpt-5-pro-2025-10-06",
+      "name_pattern": "gpt-5-pro-2025-10-06",
+      "source": "litellm",
+      "token_prices": [
+        {
+          "base_rate": 0.000015,
+          "is_prompt": true,
+          "token_type": "input"
+        },
+        {
+          "base_rate": 0.00012,
+          "is_prompt": false,
+          "token_type": "output"
+        }
+      ]
+    },
     {
       "name": "gpt-realtime",
       "name_pattern": "gpt-realtime",
@@ -2529,6 +2644,33 @@
         }
       ]
     },
+    {
+      "name": "gpt-realtime-mini",
+      "name_pattern": "gpt-realtime-mini",
+      "source": "litellm",
+      "token_prices": [
+        {
+          "base_rate": 6e-7,
+          "is_prompt": true,
+          "token_type": "input"
+        },
+        {
+          "base_rate": 2.4e-6,
+          "is_prompt": false,
+          "token_type": "output"
+        },
+        {
+          "base_rate": 0.00001,
+          "is_prompt": true,
+          "token_type": "audio"
+        },
+        {
+          "base_rate": 0.00002,
+          "is_prompt": false,
+          "token_type": "audio"
+        }
+      ]
+    },
     {
       "name": "o1",
       "name_pattern": "o1",

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

@@ -1,32 +1,28 @@
 {
-  "_components-XKc983B9.js": {
-    "file": "assets/components-XKc983B9.js",
+  "_components-X_GtZhnz.js": {
+    "file": "assets/components-X_GtZhnz.js",
     "name": "components",
     "imports": [
-      "_vendor-CQ4tN9P7.js",
-      "_pages-CSZW-lt0.js",
-      "_vendor-arizeai-Cb1ncvYH.js",
-      "_vendor-codemirror-CckmKopH.js",
+      "_vendor-3BvTzoBp.js",
+      "_pages-Dl8TWyNq.js",
+      "_vendor-arizeai-C6_oC0y8.js",
+      "_vendor-codemirror-DPnZGAZA.js",
       "_vendor-three-BtCyLs1w.js"
     ]
   },
-  "_pages-CSZW-lt0.js": {
-    "file": "assets/pages-CSZW-lt0.js",
+  "_pages-Dl8TWyNq.js": {
+    "file": "assets/pages-Dl8TWyNq.js",
     "name": "pages",
     "imports": [
-      "_vendor-CQ4tN9P7.js",
-      "_components-XKc983B9.js",
-      "_vendor-arizeai-Cb1ncvYH.js",
-      "_vendor-codemirror-CckmKopH.js",
-      "_vendor-recharts-BC1ysIKu.js"
+      "_vendor-3BvTzoBp.js",
+      "_components-X_GtZhnz.js",
+      "_vendor-arizeai-C6_oC0y8.js",
+      "_vendor-codemirror-DPnZGAZA.js",
+      "_vendor-recharts-CjgSbsB0.js"
     ]
   },
-  "_vendor-BGzfc4EU.css": {
-    "file": "assets/vendor-BGzfc4EU.css",
-    "src": "_vendor-BGzfc4EU.css"
-  },
-  "_vendor-CQ4tN9P7.js": {
-    "file": "assets/vendor-CQ4tN9P7.js",
+  "_vendor-3BvTzoBp.js": {
+    "file": "assets/vendor-3BvTzoBp.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-BtCyLs1w.js"
@@ -35,39 +31,43 @@
       "assets/vendor-BGzfc4EU.css"
     ]
   },
-  "_vendor-arizeai-Cb1ncvYH.js": {
-    "file": "assets/vendor-arizeai-Cb1ncvYH.js",
+  "_vendor-BGzfc4EU.css": {
+    "file": "assets/vendor-BGzfc4EU.css",
+    "src": "_vendor-BGzfc4EU.css"
+  },
+  "_vendor-arizeai-C6_oC0y8.js": {
+    "file": "assets/vendor-arizeai-C6_oC0y8.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-CQ4tN9P7.js"
+      "_vendor-3BvTzoBp.js"
     ]
   },
-  "_vendor-codemirror-CckmKopH.js": {
-    "file": "assets/vendor-codemirror-CckmKopH.js",
+  "_vendor-codemirror-DPnZGAZA.js": {
+    "file": "assets/vendor-codemirror-DPnZGAZA.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-CQ4tN9P7.js",
-      "_vendor-shiki-B45T-YxN.js"
+      "_vendor-3BvTzoBp.js",
+      "_vendor-shiki-CJyhDG0E.js"
     ],
     "dynamicImports": [
-      "_vendor-shiki-B45T-YxN.js",
-      "_vendor-shiki-B45T-YxN.js",
-      "_vendor-shiki-B45T-YxN.js"
+      "_vendor-shiki-CJyhDG0E.js",
+      "_vendor-shiki-CJyhDG0E.js",
+      "_vendor-shiki-CJyhDG0E.js"
     ]
   },
-  "_vendor-recharts-BC1ysIKu.js": {
-    "file": "assets/vendor-recharts-BC1ysIKu.js",
+  "_vendor-recharts-CjgSbsB0.js": {
+    "file": "assets/vendor-recharts-CjgSbsB0.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-CQ4tN9P7.js"
+      "_vendor-3BvTzoBp.js"
     ]
   },
-  "_vendor-shiki-B45T-YxN.js": {
-    "file": "assets/vendor-shiki-B45T-YxN.js",
+  "_vendor-shiki-CJyhDG0E.js": {
+    "file": "assets/vendor-shiki-CJyhDG0E.js",
     "name": "vendor-shiki",
     "isDynamicEntry": true,
     "imports": [
-      "_vendor-CQ4tN9P7.js"
+      "_vendor-3BvTzoBp.js"
     ]
   },
   "_vendor-three-BtCyLs1w.js": {
@@ -75,19 +75,19 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-DG8e74sg.js",
+    "file": "assets/index-BCtFqQdo.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-CQ4tN9P7.js",
-      "_vendor-arizeai-Cb1ncvYH.js",
-      "_pages-CSZW-lt0.js",
-      "_components-XKc983B9.js",
+      "_vendor-3BvTzoBp.js",
+      "_vendor-arizeai-C6_oC0y8.js",
+      "_pages-Dl8TWyNq.js",
+      "_components-X_GtZhnz.js",
       "_vendor-three-BtCyLs1w.js",
-      "_vendor-codemirror-CckmKopH.js",
-      "_vendor-shiki-B45T-YxN.js",
-      "_vendor-recharts-BC1ysIKu.js"
+      "_vendor-codemirror-DPnZGAZA.js",
+      "_vendor-shiki-CJyhDG0E.js",
+      "_vendor-recharts-CjgSbsB0.js"
     ]
   }
 }