arize-phoenix 12.3.0__py3-none-any.whl → 12.5.0__py3-none-any.whl

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

@@ -8,7 +8,6 @@ from fastapi import APIRouter, HTTPException, Path, Query
 from pydantic import Field
 from sqlalchemy import exists, select
 from starlette.requests import Request
-from starlette.status import HTTP_200_OK, HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
@@ -198,11 +197,11 @@ class SessionAnnotationsResponseBody(PaginatedResponseBody[SessionAnnotation]):
     "/projects/{project_identifier}/span_annotations",
     operation_id="listSpanAnnotationsBySpanIds",
     summary="Get span annotations for a list of span_ids.",
-    status_code=HTTP_200_OK,
+    status_code=200,
     responses=add_errors_to_responses(
         [
-            {"status_code": HTTP_404_NOT_FOUND, "description": "Project or spans not found"},
-            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid parameters"},
+            {"status_code": 404, "description": "Project or spans not found"},
+            {"status_code": 422, "description": "Invalid parameters"},
         ]
     ),
 )
@@ -240,7 +239,7 @@ async def list_span_annotations(
     span_ids = list({*span_ids})
     if len(span_ids) > MAX_SPAN_IDS:
         raise HTTPException(
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
             detail=f"Too many span_ids supplied: {len(span_ids)} (max {MAX_SPAN_IDS})",
         )
 
@@ -248,7 +247,7 @@ async def list_span_annotations(
         project = await _get_project_by_identifier(session, project_identifier)
         if not project:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=f"Project with identifier {project_identifier} not found",
             )
 
@@ -280,7 +279,7 @@ async def list_span_annotations(
                 cursor_id = int(GlobalID.from_id(cursor).node_id)
             except ValueError:
                 raise HTTPException(
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                     detail="Invalid cursor value",
                 )
             stmt = stmt.where(models.SpanAnnotation.id <= cursor_id)
@@ -310,7 +309,7 @@ async def list_span_annotations(
             if not spans_exist:
                 raise HTTPException(
                     detail="None of the supplied span_ids exist in this project",
-                    status_code=HTTP_404_NOT_FOUND,
+                    status_code=404,
                 )
 
             return SpanAnnotationsResponseBody(data=[], next_cursor=None)
@@ -343,11 +342,11 @@ async def list_span_annotations(
     "/projects/{project_identifier}/trace_annotations",
     operation_id="listTraceAnnotationsByTraceIds",
     summary="Get trace annotations for a list of trace_ids.",
-    status_code=HTTP_200_OK,
+    status_code=200,
     responses=add_errors_to_responses(
         [
-            {"status_code": HTTP_404_NOT_FOUND, "description": "Project or traces not found"},
-            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid parameters"},
+            {"status_code": 404, "description": "Project or traces not found"},
+            {"status_code": 422, "description": "Invalid parameters"},
         ]
     ),
 )
@@ -385,7 +384,7 @@ async def list_trace_annotations(
     trace_ids = list({*trace_ids})
     if len(trace_ids) > MAX_TRACE_IDS:
         raise HTTPException(
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
             detail=f"Too many trace_ids supplied: {len(trace_ids)} (max {MAX_TRACE_IDS})",
         )
 
@@ -393,7 +392,7 @@ async def list_trace_annotations(
         project = await _get_project_by_identifier(session, project_identifier)
         if not project:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=f"Project with identifier {project_identifier} not found",
             )
 
@@ -424,7 +423,7 @@ async def list_trace_annotations(
                 cursor_id = int(GlobalID.from_id(cursor).node_id)
             except ValueError:
                 raise HTTPException(
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                     detail="Invalid cursor value",
                 )
             stmt = stmt.where(models.TraceAnnotation.id <= cursor_id)
@@ -450,7 +449,7 @@ async def list_trace_annotations(
             if not traces_exist:
                 raise HTTPException(
                     detail="None of the supplied trace_ids exist in this project",
-                    status_code=HTTP_404_NOT_FOUND,
+                    status_code=404,
                 )
 
             return TraceAnnotationsResponseBody(data=[], next_cursor=None)
@@ -483,11 +482,11 @@ async def list_trace_annotations(
     "/projects/{project_identifier}/session_annotations",
     operation_id="listSessionAnnotationsBySessionIds",
     summary="Get session annotations for a list of session_ids.",
-    status_code=HTTP_200_OK,
+    status_code=200,
     responses=add_errors_to_responses(
         [
-            {"status_code": HTTP_404_NOT_FOUND, "description": "Project or sessions not found"},
-            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid parameters"},
+            {"status_code": 404, "description": "Project or sessions not found"},
+            {"status_code": 422, "description": "Invalid parameters"},
         ]
     ),
 )
@@ -525,7 +524,7 @@ async def list_session_annotations(
     session_ids = list({*session_ids})
     if len(session_ids) > MAX_SESSION_IDS:
         raise HTTPException(
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
             detail=f"Too many session_ids supplied: {len(session_ids)} (max {MAX_SESSION_IDS})",
         )
 
@@ -533,7 +532,7 @@ async def list_session_annotations(
         project = await _get_project_by_identifier(session, project_identifier)
         if not project:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=f"Project with identifier {project_identifier} not found",
             )
 
@@ -571,7 +570,7 @@ async def list_session_annotations(
                 cursor_id = int(GlobalID.from_id(cursor).node_id)
             except ValueError:
                 raise HTTPException(
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                     detail="Invalid cursor value",
                 )
             stmt = stmt.where(models.ProjectSessionAnnotation.id <= cursor_id)
@@ -597,7 +596,7 @@ async def list_session_annotations(
             if not sessions_exist:
                 raise HTTPException(
                     detail="None of the supplied session_ids exist in this project",
-                    status_code=HTTP_404_NOT_FOUND,
+                    status_code=404,
                 )
 
             return SessionAnnotationsResponseBody(data=[], next_cursor=None)

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

@@ -23,14 +23,6 @@ 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_200_OK,
-    HTTP_204_NO_CONTENT,
-    HTTP_404_NOT_FOUND,
-    HTTP_409_CONFLICT,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-    HTTP_429_TOO_MANY_REQUESTS,
-)
 from strawberry.relay import GlobalID
 from typing_extensions import TypeAlias, assert_never
 
@@ -91,7 +83,7 @@ class ListDatasetsResponseBody(PaginatedResponseBody[Dataset]):
     "/datasets",
     operation_id="listDatasets",
     summary="List datasets",
-    responses=add_errors_to_responses([HTTP_422_UNPROCESSABLE_ENTITY]),
+    responses=add_errors_to_responses([422]),
 )
 async def list_datasets(
     request: Request,
@@ -125,7 +117,7 @@ async def list_datasets(
             except ValueError:
                 raise HTTPException(
                     detail=f"Invalid cursor format: {cursor}",
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                 )
         if name:
             query = query.filter(models.Dataset.name == name)
@@ -164,11 +156,11 @@ async def list_datasets(
     "/datasets/{id}",
     operation_id="deleteDatasetById",
     summary="Delete dataset by ID",
-    status_code=HTTP_204_NO_CONTENT,
+    status_code=204,
     responses=add_errors_to_responses(
         [
-            {"status_code": HTTP_404_NOT_FOUND, "description": "Dataset not found"},
-            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid dataset ID"},
+            {"status_code": 404, "description": "Dataset not found"},
+            {"status_code": 422, "description": "Invalid dataset ID"},
         ]
     ),
 )
@@ -182,11 +174,9 @@ async def delete_dataset(
                 DATASET_NODE_NAME,
             )
         except ValueError:
-            raise HTTPException(
-                detail=f"Invalid Dataset ID: {id}", status_code=HTTP_422_UNPROCESSABLE_ENTITY
-            )
+            raise HTTPException(detail=f"Invalid Dataset ID: {id}", status_code=422)
     else:
-        raise HTTPException(detail="Missing Dataset ID", status_code=HTTP_422_UNPROCESSABLE_ENTITY)
+        raise HTTPException(detail="Missing Dataset ID", status_code=422)
     project_names_stmt = get_project_names_for_datasets(dataset_id)
     eval_trace_ids_stmt = get_eval_trace_ids_for_datasets(dataset_id)
     stmt = (
@@ -196,7 +186,7 @@ async def delete_dataset(
         project_names = await session.scalars(project_names_stmt)
         eval_trace_ids = await session.scalars(eval_trace_ids_stmt)
         if (await session.scalar(stmt)) is None:
-            raise HTTPException(detail="Dataset does not exist", status_code=HTTP_404_NOT_FOUND)
+            raise HTTPException(detail="Dataset does not exist", status_code=404)
     tasks = BackgroundTasks()
     tasks.add_task(delete_projects, request.app.state.db, *project_names)
     tasks.add_task(delete_traces, request.app.state.db, *eval_trace_ids)
@@ -214,17 +204,21 @@ class GetDatasetResponseBody(ResponseBody[DatasetWithExampleCount]):
     "/datasets/{id}",
     operation_id="getDataset",
     summary="Get dataset by ID",
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND]),
+    responses=add_errors_to_responses([404]),
 )
 async def get_dataset(
     request: Request, id: str = Path(description="The ID of the dataset")
 ) -> GetDatasetResponseBody:
-    dataset_id = GlobalID.from_id(id)
+    try:
+        dataset_id = GlobalID.from_id(id)
+    except Exception as e:
+        raise HTTPException(
+            detail=f"Invalid dataset ID format: {id}",
+            status_code=422,
+        ) from e
 
     if (type_name := dataset_id.type_name) != DATASET_NODE_NAME:
-        raise HTTPException(
-            detail=f"ID {dataset_id} refers to a f{type_name}", status_code=HTTP_404_NOT_FOUND
-        )
+        raise HTTPException(detail=f"ID {dataset_id} refers to a f{type_name}", status_code=404)
     async with request.app.state.db() as session:
         result = await session.execute(
             select(models.Dataset, models.Dataset.example_count).filter(
@@ -235,9 +229,7 @@ async def get_dataset(
         dataset = dataset_query[0] if dataset_query else None
         example_count = dataset_query[1] if dataset_query else 0
         if dataset is None:
-            raise HTTPException(
-                detail=f"Dataset with ID {dataset_id} not found", status_code=HTTP_404_NOT_FOUND
-            )
+            raise HTTPException(detail=f"Dataset with ID {dataset_id} not found", status_code=404)
 
         dataset = DatasetWithExampleCount(
             id=str(dataset_id),
@@ -266,7 +258,7 @@ class ListDatasetVersionsResponseBody(PaginatedResponseBody[DatasetVersion]):
     "/datasets/{id}/versions",
     operation_id="listDatasetVersionsByDatasetId",
     summary="List dataset versions",
-    responses=add_errors_to_responses([HTTP_422_UNPROCESSABLE_ENTITY]),
+    responses=add_errors_to_responses([422]),
 )
 async def list_dataset_versions(
     request: Request,
@@ -288,12 +280,12 @@ async def list_dataset_versions(
         except ValueError:
             raise HTTPException(
                 detail=f"Invalid Dataset ID: {id}",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
             )
     else:
         raise HTTPException(
             detail="Missing Dataset ID",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
     stmt = (
         select(models.DatasetVersion)
@@ -309,7 +301,7 @@ async def list_dataset_versions(
         except ValueError:
             raise HTTPException(
                 detail=f"Invalid cursor: {cursor}",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
             )
         max_dataset_version_id = (
             select(models.DatasetVersion.id)
@@ -348,10 +340,10 @@ class UploadDatasetResponseBody(ResponseBody[UploadDatasetData]):
     responses=add_errors_to_responses(
         [
             {
-                "status_code": HTTP_409_CONFLICT,
+                "status_code": 409,
                 "description": "Dataset of the same name already exists",
             },
-            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid request body"},
+            {"status_code": 422, "description": "Invalid request body"},
         ]
     ),
     # FastAPI cannot generate the request body portion of the OpenAPI schema for
@@ -414,7 +406,12 @@ async def upload_dataset(
         description="If true, fulfill request synchronously and return JSON containing dataset_id.",
     ),
 ) -> Optional[UploadDatasetResponseBody]:
-    request_content_type = request.headers["content-type"]
+    request_content_type = request.headers.get("content-type")
+    if not request_content_type:
+        raise HTTPException(
+            detail="Missing content-type header",
+            status_code=400,
+        )
     examples: Union[Examples, Awaitable[Examples]]
     if request_content_type.startswith("application/json"):
         try:
@@ -424,14 +421,14 @@ async def upload_dataset(
         except ValueError as e:
             raise HTTPException(
                 detail=str(e),
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
             )
         if action is DatasetAction.CREATE:
             async with request.app.state.db() as session:
                 if await _check_table_exists(session, name):
                     raise HTTPException(
                         detail=f"Dataset with the same name already exists: {name=}",
-                        status_code=HTTP_409_CONFLICT,
+                        status_code=409,
                     )
     elif request_content_type.startswith("multipart/form-data"):
         async with request.form() as form:
@@ -448,14 +445,14 @@ async def upload_dataset(
             except ValueError as e:
                 raise HTTPException(
                     detail=str(e),
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                 )
             if action is DatasetAction.CREATE:
                 async with request.app.state.db() as session:
                     if await _check_table_exists(session, name):
                         raise HTTPException(
                             detail=f"Dataset with the same name already exists: {name=}",
-                            status_code=HTTP_409_CONFLICT,
+                            status_code=409,
                         )
             content = await file.read()
         try:
@@ -472,12 +469,12 @@ async def upload_dataset(
         except ValueError as e:
             raise HTTPException(
                 detail=str(e),
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
             )
     else:
         raise HTTPException(
             detail="Invalid request Content-Type",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
     user_id: Optional[int] = None
     if request.app.state.authentication_enabled and isinstance(request.user, PhoenixUser):
@@ -510,7 +507,7 @@ async def upload_dataset(
     except QueueFull:
         if isinstance(examples, Coroutine):
             examples.close()
-        raise HTTPException(detail="Too many requests.", status_code=HTTP_429_TOO_MANY_REQUESTS)
+        raise HTTPException(detail="Too many requests.", status_code=429)
     return None
 
 
@@ -711,7 +708,7 @@ class ListDatasetExamplesResponseBody(ResponseBody[ListDatasetExamplesData]):
     "/datasets/{id}/examples",
     operation_id="getDatasetExamples",
     summary="Get examples from a dataset",
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND]),
+    responses=add_errors_to_responses([404]),
 )
 async def get_dataset_examples(
     request: Request,
@@ -723,18 +720,30 @@ async def get_dataset_examples(
         ),
     ),
 ) -> ListDatasetExamplesResponseBody:
-    dataset_gid = GlobalID.from_id(id)
-    version_gid = GlobalID.from_id(version_id) if version_id else None
+    try:
+        dataset_gid = GlobalID.from_id(id)
+    except Exception as e:
+        raise HTTPException(
+            detail=f"Invalid dataset ID format: {id}",
+            status_code=422,
+        ) from e
+
+    if version_id:
+        try:
+            version_gid = GlobalID.from_id(version_id)
+        except Exception as e:
+            raise HTTPException(
+                detail=f"Invalid dataset version ID format: {version_id}",
+                status_code=422,
+            ) from e
+    else:
+        version_gid = None
 
     if (dataset_type := dataset_gid.type_name) != "Dataset":
-        raise HTTPException(
-            detail=f"ID {dataset_gid} refers to a {dataset_type}", status_code=HTTP_404_NOT_FOUND
-        )
+        raise HTTPException(detail=f"ID {dataset_gid} refers to a {dataset_type}", status_code=404)
 
     if version_gid and (version_type := version_gid.type_name) != "DatasetVersion":
-        raise HTTPException(
-            detail=f"ID {version_gid} refers to a {version_type}", status_code=HTTP_404_NOT_FOUND
-        )
+        raise HTTPException(detail=f"ID {version_gid} refers to a {version_type}", status_code=404)
 
     async with request.app.state.db() as session:
         if (
@@ -744,7 +753,7 @@ async def get_dataset_examples(
         ) is None:
             raise HTTPException(
                 detail=f"No dataset with id {dataset_gid} can be found.",
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
             )
 
         # Subquery to find the maximum created_at for each dataset_example_id
@@ -766,7 +775,7 @@ async def get_dataset_examples(
             ) is None:
                 raise HTTPException(
                     detail=f"No dataset version with id {version_id} can be found.",
-                    status_code=HTTP_404_NOT_FOUND,
+                    status_code=404,
                 )
             # if a version_id is provided, filter the subquery to only include revisions from that
             partial_subquery = partial_subquery.filter(
@@ -782,7 +791,7 @@ async def get_dataset_examples(
             ) is None:
                 raise HTTPException(
                     detail="Dataset has no versions.",
-                    status_code=HTTP_404_NOT_FOUND,
+                    status_code=404,
                 )
 
         subquery = partial_subquery.subquery()
@@ -825,10 +834,10 @@ async def get_dataset_examples(
     operation_id="getDatasetCsv",
     summary="Download dataset examples as CSV file",
     response_class=StreamingResponse,
-    status_code=HTTP_200_OK,
+    status_code=200,
     responses={
-        **add_errors_to_responses([HTTP_422_UNPROCESSABLE_ENTITY]),
-        **add_text_csv_content_to_responses(HTTP_200_OK),
+        **add_errors_to_responses([422]),
+        **add_text_csv_content_to_responses(200),
     },
 )
 async def get_dataset_csv(
@@ -848,7 +857,7 @@ async def get_dataset_csv(
                 session=session, id=id, version_id=version_id
             )
     except ValueError as e:
-        raise HTTPException(detail=str(e), status_code=HTTP_422_UNPROCESSABLE_ENTITY)
+        raise HTTPException(detail=str(e), status_code=422)
     content = await run_in_threadpool(_get_content_csv, examples)
     encoded_dataset_name = urllib.parse.quote(dataset_name)
     return Response(
@@ -868,7 +877,7 @@ async def get_dataset_csv(
     responses=add_errors_to_responses(
         [
             {
-                "status_code": HTTP_422_UNPROCESSABLE_ENTITY,
+                "status_code": 422,
                 "description": "Invalid dataset or version ID",
             }
         ]
@@ -891,7 +900,7 @@ async def get_dataset_jsonl_openai_ft(
                 session=session, id=id, version_id=version_id
             )
     except ValueError as e:
-        raise HTTPException(detail=str(e), status_code=HTTP_422_UNPROCESSABLE_ENTITY)
+        raise HTTPException(detail=str(e), status_code=422)
     content = await run_in_threadpool(_get_content_jsonl_openai_ft, examples)
     encoded_dataset_name = urllib.parse.quote(dataset_name)
     response.headers["content-disposition"] = (
@@ -908,7 +917,7 @@ async def get_dataset_jsonl_openai_ft(
     responses=add_errors_to_responses(
         [
             {
-                "status_code": HTTP_422_UNPROCESSABLE_ENTITY,
+                "status_code": 422,
                 "description": "Invalid dataset or version ID",
             }
         ]
@@ -931,7 +940,7 @@ async def get_dataset_jsonl_openai_evals(
                 session=session, id=id, version_id=version_id
             )
     except ValueError as e:
-        raise HTTPException(detail=str(e), status_code=HTTP_422_UNPROCESSABLE_ENTITY)
+        raise HTTPException(detail=str(e), status_code=422)
     content = await run_in_threadpool(_get_content_jsonl_openai_evals, examples)
     encoded_dataset_name = urllib.parse.quote(dataset_name)
     response.headers["content-disposition"] = (
@@ -1010,12 +1019,25 @@ def _get_content_jsonl_openai_evals(examples: list[models.DatasetExampleRevision
 async def _get_db_examples(
     *, session: Any, id: str, version_id: Optional[str]
 ) -> tuple[str, list[models.DatasetExampleRevision]]:
-    dataset_id = from_global_id_with_expected_type(GlobalID.from_id(id), DATASET_NODE_NAME)
+    try:
+        dataset_id = from_global_id_with_expected_type(GlobalID.from_id(id), DATASET_NODE_NAME)
+    except Exception as e:
+        raise HTTPException(
+            detail=f"Invalid dataset ID format: {id}",
+            status_code=422,
+        ) from e
+
     dataset_version_id: Optional[int] = None
     if version_id:
-        dataset_version_id = from_global_id_with_expected_type(
-            GlobalID.from_id(version_id), DATASET_VERSION_NODE_NAME
-        )
+        try:
+            dataset_version_id = from_global_id_with_expected_type(
+                GlobalID.from_id(version_id), DATASET_VERSION_NODE_NAME
+            )
+        except Exception as e:
+            raise HTTPException(
+                detail=f"Invalid dataset version ID format: {version_id}",
+                status_code=422,
+            ) from e
     latest_version = (
         select(
             models.DatasetExampleRevision.dataset_example_id,

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

@@ -4,7 +4,6 @@ from fastapi import APIRouter, Depends, HTTPException, Query
 from pydantic import Field
 from sqlalchemy import select
 from starlette.requests import Request
-from starlette.status import HTTP_404_NOT_FOUND
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
@@ -42,7 +41,7 @@ class AnnotateSpanDocumentsResponseBody(ResponseBody[list[InsertedSpanDocumentAn
     responses=add_errors_to_responses(
         [
             {
-                "status_code": HTTP_404_NOT_FOUND,
+                "status_code": 404,
                 "description": "Span not found",
             },
             {
@@ -102,7 +101,7 @@ async def annotate_span_documents(
         if missing_span_ids:
             raise HTTPException(
                 detail=f"Spans with IDs {', '.join(missing_span_ids)} do not exist.",
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
             )
 
         # Validate that document positions are within bounds

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

@@ -15,12 +15,6 @@ from starlette.background import BackgroundTask
 from starlette.datastructures import State
 from starlette.requests import Request
 from starlette.responses import Response, StreamingResponse
-from starlette.status import (
-    HTTP_204_NO_CONTENT,
-    HTTP_404_NOT_FOUND,
-    HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-)
 from typing_extensions import TypeAlias
 
 import phoenix.trace.v1 as pb
@@ -50,16 +44,16 @@ router = APIRouter(tags=["traces"], include_in_schema=True)
     dependencies=[Depends(is_not_locked)],
     operation_id="addEvaluations",
     summary="Add span, trace, or document evaluations",
-    status_code=HTTP_204_NO_CONTENT,
+    status_code=204,
     responses=add_errors_to_responses(
         [
             {
-                "status_code": HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+                "status_code": 415,
                 "description": (
                     "Unsupported content type, only gzipped protobuf and pandas-arrow are supported"
                 ),
             },
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            422,
         ]
     ),
     openapi_extra={
@@ -80,27 +74,21 @@ async def post_evaluations(
     if content_type == "application/x-pandas-arrow":
         return await _process_pyarrow(request)
     if content_type != "application/x-protobuf":
-        raise HTTPException(
-            detail="Unsupported content type", status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE
-        )
+        raise HTTPException(detail="Unsupported content type", status_code=415)
     body = await request.body()
     if content_encoding == "gzip":
         body = gzip.decompress(body)
     elif content_encoding:
-        raise HTTPException(
-            detail="Unsupported content encoding", status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE
-        )
+        raise HTTPException(detail="Unsupported content encoding", status_code=415)
     evaluation = pb.Evaluation()
     try:
         evaluation.ParseFromString(body)
     except DecodeError:
-        raise HTTPException(
-            detail="Request body is invalid", status_code=HTTP_422_UNPROCESSABLE_ENTITY
-        )
+        raise HTTPException(detail="Request body is invalid", status_code=422)
     if not evaluation.name.strip():
         raise HTTPException(
             detail="Evaluation name must not be blank/empty",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
     await request.state.enqueue_evaluation(evaluation)
     return Response()
@@ -110,7 +98,7 @@ async def post_evaluations(
     "/evaluations",
     operation_id="getEvaluations",
     summary="Get span, trace, or document evaluations from a project",
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND]),
+    responses=add_errors_to_responses([404]),
 )
 async def get_evaluations(
     request: Request,
@@ -149,7 +137,7 @@ async def get_evaluations(
         and span_evals_dataframe.empty
         and document_evals_dataframe.empty
     ):
-        return Response(status_code=HTTP_404_NOT_FOUND)
+        return Response(status_code=404)
 
     evals = chain(
         map(
@@ -179,7 +167,7 @@ async def _process_pyarrow(request: Request) -> Response:
     except pa.ArrowInvalid:
         raise HTTPException(
             detail="Request body is not valid pyarrow",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
     try:
         evaluations = Evaluations.from_pyarrow_reader(reader)
@@ -187,11 +175,11 @@ async def _process_pyarrow(request: Request) -> Response:
         if isinstance(e, PhoenixEvaluationNameIsMissing):
             raise HTTPException(
                 detail="Evaluation name must not be blank/empty",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
             )
         raise HTTPException(
             detail="Invalid data in request body",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
     return Response(background=BackgroundTask(_add_evaluations, request.state, evaluations))