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

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

@@ -6,7 +6,6 @@ from pydantic import ValidationError, model_validator
 from sqlalchemy import select
 from sqlalchemy.sql import Select
 from starlette.requests import Request
-from starlette.status import HTTP_204_NO_CONTENT, HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
 from strawberry.relay import GlobalID
 from typing_extensions import Self, TypeAlias, assert_never
 
@@ -110,7 +109,7 @@ router = APIRouter(tags=["prompts"])
     response_description="A list of prompts with pagination information",
     responses=add_errors_to_responses(
         [
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            422,
         ]
     ),
 )
@@ -154,7 +153,7 @@ async def get_prompts(
             except ValueError:
                 raise HTTPException(
                     detail=f"Invalid cursor format: {cursor}",
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                 )
 
         query = query.limit(limit + 1)
@@ -181,7 +180,7 @@ async def get_prompts(
     description="Retrieve all versions of a specific prompt with pagination support. Each prompt "
     "can have multiple versions with different configurations.",
     response_description="A list of prompt versions with pagination information",
-    responses=add_errors_to_responses([HTTP_422_UNPROCESSABLE_ENTITY, HTTP_404_NOT_FOUND]),
+    responses=add_errors_to_responses([422, 404]),
     response_model_by_alias=True,
     response_model_exclude_defaults=True,
     response_model_exclude_unset=True,
@@ -226,7 +225,7 @@ async def list_prompt_versions(
             except ValueError:
                 raise HTTPException(
                     detail=f"Invalid cursor format: {cursor}",
-                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    status_code=422,
                 )
 
         query = query.limit(limit + 1)
@@ -255,8 +254,8 @@ async def list_prompt_versions(
     response_description="The requested prompt version",
     responses=add_errors_to_responses(
         [
-            HTTP_404_NOT_FOUND,
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            404,
+            422,
         ]
     ),
     response_model_by_alias=True,
@@ -286,11 +285,11 @@ async def get_prompt_version_by_prompt_version_id(
             PromptVersionNodeType.__name__,
         )
     except ValueError:
-        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt version ID")
+        raise HTTPException(422, "Invalid prompt version ID")
     async with request.app.state.db() as session:
         prompt_version = await session.get(models.PromptVersion, id_)
         if prompt_version is None:
-            raise HTTPException(HTTP_404_NOT_FOUND)
+            raise HTTPException(404)
     data = _prompt_version_from_orm_version(prompt_version)
     return GetPromptResponseBody(data=data)
 
@@ -304,8 +303,8 @@ async def get_prompt_version_by_prompt_version_id(
     response_description="The prompt version with the specified tag",
     responses=add_errors_to_responses(
         [
-            HTTP_404_NOT_FOUND,
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            404,
+            422,
         ]
     ),
     response_model_by_alias=True,
@@ -334,7 +333,7 @@ async def get_prompt_version_by_tag_name(
     try:
         name = Identifier.model_validate(tag_name)
     except ValidationError:
-        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid tag name")
+        raise HTTPException(422, "Invalid tag name")
     stmt = (
         select(models.PromptVersion)
         .join_from(models.PromptVersion, models.PromptVersionTag)
@@ -344,7 +343,7 @@ async def get_prompt_version_by_tag_name(
     async with request.app.state.db() as session:
         prompt_version: models.PromptVersion = await session.scalar(stmt)
         if prompt_version is None:
-            raise HTTPException(HTTP_404_NOT_FOUND)
+            raise HTTPException(404)
     data = _prompt_version_from_orm_version(prompt_version)
     return GetPromptResponseBody(data=data)
 
@@ -357,8 +356,8 @@ async def get_prompt_version_by_tag_name(
     response_description="The latest version of the specified prompt",
     responses=add_errors_to_responses(
         [
-            HTTP_404_NOT_FOUND,
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            404,
+            422,
         ]
     ),
     response_model_by_alias=True,
@@ -387,7 +386,7 @@ async def get_prompt_version_by_latest(
     async with request.app.state.db() as session:
         prompt_version: models.PromptVersion = await session.scalar(stmt)
         if prompt_version is None:
-            raise HTTPException(HTTP_404_NOT_FOUND)
+            raise HTTPException(404)
     data = _prompt_version_from_orm_version(prompt_version)
     return GetPromptResponseBody(data=data)
 
@@ -401,7 +400,7 @@ async def get_prompt_version_by_latest(
     response_description="The newly created prompt version",
     responses=add_errors_to_responses(
         [
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            422,
         ]
     ),
     response_model_by_alias=True,
@@ -431,7 +430,7 @@ async def create_prompt(
         or request_body.version.template_type != PromptTemplateType.CHAT
     ):
         raise HTTPException(
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            422,
             "Only CHAT template type is supported for prompts",
         )
     prompt = request_body.prompt
@@ -439,7 +438,7 @@ async def create_prompt(
         name = Identifier.model_validate(prompt.name)
     except ValidationError as e:
         raise HTTPException(
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            422,
             "Invalid name identifier for prompt: " + e.errors()[0]["msg"],
         )
     version = request_body.version
@@ -496,8 +495,8 @@ class GetPromptVersionTagsResponseBody(PaginatedResponseBody[PromptVersionTag]):
     response_description="A list of tags associated with the prompt version",
     responses=add_errors_to_responses(
         [
-            HTTP_404_NOT_FOUND,
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            404,
+            422,
         ]
     ),
     response_model_by_alias=True,
@@ -537,7 +536,7 @@ async def list_prompt_version_tags(
             PromptVersionNodeType.__name__,
         )
     except ValueError:
-        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt version ID")
+        raise HTTPException(422, "Invalid prompt version ID")
 
     # Build the query for tags
     stmt = (
@@ -560,7 +559,7 @@ async def list_prompt_version_tags(
         except ValueError:
             raise HTTPException(
                 detail=f"Invalid cursor format: {cursor}",
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
             )
 
     # Apply limit
@@ -571,7 +570,7 @@ async def list_prompt_version_tags(
 
     # Check if prompt version exists
     if not result:
-        raise HTTPException(HTTP_404_NOT_FOUND, "Prompt version not found")
+        raise HTTPException(404, "Prompt version not found")
 
     # Check if there are any tags
     has_tags = any(id_ is not None for _, id_, _, _ in result)
@@ -610,11 +609,11 @@ async def list_prompt_version_tags(
     description="Add a new tag to a specific prompt version. Tags help identify and categorize "
     "different versions of a prompt.",
     response_description="No content returned on successful tag creation",
-    status_code=HTTP_204_NO_CONTENT,
+    status_code=204,
     responses=add_errors_to_responses(
         [
-            HTTP_404_NOT_FOUND,
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            404,
+            422,
         ]
     ),
     response_model_by_alias=True,
@@ -647,7 +646,7 @@ async def create_prompt_version_tag(
             PromptVersionNodeType.__name__,
         )
     except ValueError:
-        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt version ID")
+        raise HTTPException(422, "Invalid prompt version ID")
     user_id: Optional[int] = None
     if request.app.state.authentication_enabled:
         assert isinstance(user := request.user, PhoenixUser)
@@ -655,7 +654,7 @@ async def create_prompt_version_tag(
     async with request.app.state.db() as session:
         prompt_id = await session.scalar(select(models.PromptVersion.prompt_id).filter_by(id=id_))
         if prompt_id is None:
-            raise HTTPException(HTTP_404_NOT_FOUND)
+            raise HTTPException(404)
         dialect = SupportedSQLDialect(session.bind.dialect.name)
         values = dict(
             name=request_body.name,
@@ -686,7 +685,7 @@ def _parse_prompt_identifier(
     prompt_identifier: str,
 ) -> _PromptIdentifier:
     if not prompt_identifier:
-        raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt identifier")
+        raise HTTPException(422, "Invalid prompt identifier")
     try:
         prompt_id = from_global_id_with_expected_type(
             GlobalID.from_id(prompt_identifier),
@@ -696,7 +695,7 @@ def _parse_prompt_identifier(
         try:
             return Identifier.model_validate(prompt_identifier)
         except ValidationError:
-            raise HTTPException(HTTP_422_UNPROCESSABLE_ENTITY, "Invalid prompt name")
+            raise HTTPException(422, "Invalid prompt name")
     return _PromptId(prompt_id)
 
 

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

@@ -7,7 +7,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 phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
@@ -39,9 +38,7 @@ class AnnotateSessionsResponseBody(ResponseBody[list[InsertedSessionAnnotation]]
     dependencies=[Depends(is_not_locked)],
     operation_id="annotateSessions",
     summary="Create session annotations",
-    responses=add_errors_to_responses(
-        [{"status_code": HTTP_404_NOT_FOUND, "description": "Session not found"}]
-    ),
+    responses=add_errors_to_responses([{"status_code": 404, "description": "Session not found"}]),
     response_description="Session annotations inserted successfully",
     include_in_schema=True,
 )
@@ -88,7 +85,7 @@ async def annotate_sessions(
     if missing_session_ids:
         raise HTTPException(
             detail=f"Sessions with IDs {', '.join(missing_session_ids)} do not exist.",
-            status_code=HTTP_404_NOT_FOUND,
+            status_code=404,
         )
 
     async with request.app.state.db() as session:

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

@@ -14,12 +14,7 @@ from pydantic import BaseModel, Field
 from sqlalchemy import exists, select, update
 from starlette.requests import Request
 from starlette.responses import Response, StreamingResponse
-from starlette.status import (
-    HTTP_202_ACCEPTED,
-    HTTP_400_BAD_REQUEST,
-    HTTP_404_NOT_FOUND,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-)
+from starlette.status import HTTP_404_NOT_FOUND
 from strawberry.relay import GlobalID
 
 from phoenix.config import DEFAULT_PROJECT_NAME
@@ -33,7 +28,7 @@ from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.authorization import is_not_locked
 from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import SpanAnnotationInsertEvent, SpanDeleteEvent
-from phoenix.trace.attributes import flatten
+from phoenix.trace.attributes import flatten, unflatten
 from phoenix.trace.dsl import SpanQuery as SpanQuery_
 from phoenix.trace.schemas import (
     Span as SpanForInsertion,
@@ -440,7 +435,7 @@ class SpansResponseBody(PaginatedResponseBody[Span]):
     "/spans",
     operation_id="querySpans",
     summary="Query spans with query DSL",
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY]),
+    responses=add_errors_to_responses([404, 422]),
     include_in_schema=False,
 )
 async def query_spans_handler(
@@ -467,7 +462,7 @@ async def query_spans_handler(
     except Exception as e:
         raise HTTPException(
             detail=f"Invalid query: {e}",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
 
     async with request.app.state.db() as session:
@@ -490,7 +485,7 @@ async def query_spans_handler(
             )
             results.append(df)
     if not results:
-        raise HTTPException(status_code=HTTP_404_NOT_FOUND)
+        raise HTTPException(status_code=404)
 
     if accept == "application/json":
         boundary_token = token_urlsafe(64)
@@ -574,7 +569,7 @@ def _to_any_value(value: Any) -> OtlpAnyValue:
     summary="Search spans with simple filters (no DSL)",
     description="Return spans within a project filtered by time range. "
     "Supports cursor-based pagination.",
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY]),
+    responses=add_errors_to_responses([404, 422]),
 )
 async def span_search_otlpv1(
     request: Request,
@@ -617,7 +612,7 @@ async def span_search_otlpv1(
             cursor_rowid = int(GlobalID.from_id(cursor).node_id)
             stmt = stmt.where(models.Span.id <= cursor_rowid)
         except Exception:
-            raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid cursor")
+            raise HTTPException(status_code=422, detail="Invalid cursor")
 
     stmt = stmt.limit(limit + 1)
 
@@ -711,7 +706,7 @@ async def span_search_otlpv1(
     summary="List spans with simple filters (no DSL)",
     description="Return spans within a project filtered by time range. "
     "Supports cursor-based pagination.",
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY]),
+    responses=add_errors_to_responses([404, 422]),
 )
 async def span_search(
     request: Request,
@@ -751,7 +746,7 @@ async def span_search(
         try:
             cursor_rowid = int(GlobalID.from_id(cursor).node_id)
         except Exception:
-            raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid cursor")
+            raise HTTPException(status_code=422, detail="Invalid cursor")
         stmt = stmt.where(models.Span.id <= cursor_rowid)
 
     stmt = stmt.limit(limit + 1)
@@ -867,9 +862,7 @@ class AnnotateSpansResponseBody(ResponseBody[list[InsertedSpanAnnotation]]):
     dependencies=[Depends(is_not_locked)],
     operation_id="annotateSpans",
     summary="Create span annotations",
-    responses=add_errors_to_responses(
-        [{"status_code": HTTP_404_NOT_FOUND, "description": "Span not found"}]
-    ),
+    responses=add_errors_to_responses([{"status_code": 404, "description": "Span not found"}]),
     response_description="Span annotations inserted successfully",
     include_in_schema=True,
 )
@@ -915,7 +908,7 @@ async def annotate_spans(
         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,
             )
         inserted_ids = []
         dialect = SupportedSQLDialect(session.bind.dialect.name)
@@ -957,8 +950,8 @@ class CreateSpansResponseBody(V1RoutesBaseModel):
         "Submit spans to be inserted into a project. If any spans are invalid or "
         "duplicates, no spans will be inserted."
     ),
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_400_BAD_REQUEST]),
-    status_code=HTTP_202_ACCEPTED,
+    responses=add_errors_to_responses([404, 400]),
+    status_code=202,
 )
 async def create_spans(
     request: Request,
@@ -997,6 +990,7 @@ async def create_spans(
         # Add back the openinference.span.kind attribute since it's stored separately in the API
         attributes = dict(api_span.attributes)
         attributes["openinference.span.kind"] = api_span.span_kind
+        attributes = unflatten(attributes.items())
 
         # Create span for insertion - note we ignore the 'id' field as it's server-generated
         return SpanForInsertion(
@@ -1015,8 +1009,23 @@ async def create_spans(
             conversation=None,  # Unused
         )
 
-    async with request.app.state.db() as session:
-        project = await _get_project_by_identifier(session, project_identifier)
+    try:
+        id_ = from_global_id_with_expected_type(
+            GlobalID.from_id(project_identifier),
+            "Project",
+        )
+    except Exception:
+        project_name = project_identifier
+    else:
+        stmt = select(models.Project).filter_by(id=id_)
+        async with request.app.state.db() as session:
+            project = await session.scalar(stmt)
+        if project is None:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Project with ID {project_identifier} not found",
+            )
+        project_name = project.name
 
     total_received = len(request_body.data)
     duplicate_spans: list[dict[str, str]] = []
@@ -1044,7 +1053,7 @@ async def create_spans(
 
         try:
             span_for_insertion = convert_api_span_for_insertion(api_span)
-            spans_to_queue.append((span_for_insertion, project.name))
+            spans_to_queue.append((span_for_insertion, project_name))
         except Exception as e:
             invalid_spans.append(
                 {
@@ -1066,7 +1075,7 @@ async def create_spans(
             "invalid_spans": invalid_spans,
         }
         raise HTTPException(
-            status_code=HTTP_400_BAD_REQUEST,
+            status_code=400,
             detail=json.dumps(error_detail),
         )
 
@@ -1102,7 +1111,7 @@ async def create_spans(
         **Note**: This operation is irreversible and may create orphaned spans.
         """
     ),
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND]),
+    responses=add_errors_to_responses([404]),
     status_code=204,  # No Content for successful deletion
 )
 async def delete_span(
@@ -1154,7 +1163,7 @@ async def delete_span(
 
         if target_span is None:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=error_detail,
             )
 

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

@@ -14,12 +14,6 @@ from starlette.concurrency import run_in_threadpool
 from starlette.datastructures import State
 from starlette.requests import Request
 from starlette.responses import Response
-from starlette.status import (
-    HTTP_404_NOT_FOUND,
-    HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-    HTTP_503_SERVICE_UNAVAILABLE,
-)
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
@@ -49,7 +43,7 @@ def is_not_at_capacity(request: Request) -> None:
         SPAN_QUEUE_REJECTIONS.inc()
         raise HTTPException(
             detail="Server is at capacity and cannot process more requests",
-            status_code=HTTP_503_SERVICE_UNAVAILABLE,
+            status_code=503,
         )
 
 
@@ -61,14 +55,14 @@ def is_not_at_capacity(request: Request) -> None:
     responses=add_errors_to_responses(
         [
             {
-                "status_code": HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+                "status_code": 415,
                 "description": (
                     "Unsupported content type (only `application/x-protobuf` is supported)"
                 ),
             },
-            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid request body"},
+            {"status_code": 422, "description": "Invalid request body"},
             {
-                "status_code": HTTP_503_SERVICE_UNAVAILABLE,
+                "status_code": 503,
                 "description": "Server is at capacity and cannot process more requests",
             },
         ]
@@ -92,12 +86,12 @@ async def post_traces(
     if content_type != "application/x-protobuf":
         raise HTTPException(
             detail=f"Unsupported content type: {content_type}",
-            status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            status_code=415,
         )
     if content_encoding and content_encoding not in ("gzip", "deflate"):
         raise HTTPException(
             detail=f"Unsupported content encoding: {content_encoding}",
-            status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            status_code=415,
         )
     body = await request.body()
     if content_encoding == "gzip":
@@ -110,7 +104,7 @@ async def post_traces(
     except DecodeError:
         raise HTTPException(
             detail="Request body is invalid ExportTraceServiceRequest",
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            status_code=422,
         )
     background_tasks.add_task(_add_spans, req, request.state)
 
@@ -141,9 +135,7 @@ class AnnotateTracesResponseBody(ResponseBody[list[InsertedTraceAnnotation]]):
     dependencies=[Depends(is_not_locked)],
     operation_id="annotateTraces",
     summary="Create trace annotations",
-    responses=add_errors_to_responses(
-        [{"status_code": HTTP_404_NOT_FOUND, "description": "Trace not found"}]
-    ),
+    responses=add_errors_to_responses([{"status_code": 404, "description": "Trace not found"}]),
 )
 async def annotate_traces(
     request: Request,
@@ -177,7 +169,7 @@ async def annotate_traces(
         if missing_trace_ids:
             raise HTTPException(
                 detail=f"Traces with IDs {', '.join(missing_trace_ids)} do not exist.",
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
             )
         inserted_ids = []
         dialect = SupportedSQLDialect(session.bind.dialect.name)
@@ -220,7 +212,7 @@ async def _add_spans(req: ExportTraceServiceRequest, state: State) -> None:
         "2. An OpenTelemetry trace_id (hex string)\n\n"
         "This will permanently remove all spans in the trace and their associated data."
     ),
-    responses=add_errors_to_responses([HTTP_404_NOT_FOUND]),
+    responses=add_errors_to_responses([404]),
     status_code=204,  # No Content for successful deletion
 )
 async def delete_trace(
@@ -268,7 +260,7 @@ async def delete_trace(
 
         if project_id is None:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=error_detail,
             )
 

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

@@ -12,15 +12,6 @@ from sqlalchemy.exc import IntegrityError as PostgreSQLIntegrityError
 from sqlalchemy.orm import joinedload
 from sqlean.dbapi2 import IntegrityError as SQLiteIntegrityError  # type: ignore[import-untyped]
 from starlette.datastructures import Secret
-from starlette.status import (
-    HTTP_201_CREATED,
-    HTTP_204_NO_CONTENT,
-    HTTP_400_BAD_REQUEST,
-    HTTP_403_FORBIDDEN,
-    HTTP_404_NOT_FOUND,
-    HTTP_409_CONFLICT,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-)
 from strawberry.relay import GlobalID
 from typing_extensions import TypeAlias, assert_never
 
@@ -113,7 +104,7 @@ DEFAULT_PAGINATION_PAGE_LIMIT = 100
     response_description="A list of users.",
     responses=add_errors_to_responses(
         [
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            422,
         ],
     ),
     dependencies=[Depends(require_admin)],
@@ -187,12 +178,12 @@ async def list_users(
     summary="Create a new user",
     description="Create a new user with the specified configuration.",
     response_description="The newly created user.",
-    status_code=HTTP_201_CREATED,
+    status_code=201,
     responses=add_errors_to_responses(
         [
-            {"status_code": HTTP_400_BAD_REQUEST, "description": "Role not found."},
-            {"status_code": HTTP_409_CONFLICT, "description": "Username or email already exists."},
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            {"status_code": 400, "description": "Role not found."},
+            {"status_code": 409, "description": "Username or email already exists."},
+            422,
         ]
     ),
     dependencies=[Depends(require_admin), Depends(is_not_locked)],
@@ -213,14 +204,14 @@ async def create_user(
     # Prevent creation of SYSTEM users
     if role == "SYSTEM":
         raise HTTPException(
-            status_code=HTTP_400_BAD_REQUEST,
+            status_code=400,
             detail="Cannot create users with SYSTEM role",
         )
 
     # TODO: Implement VIEWER role
     if role == "VIEWER":
         raise HTTPException(
-            status_code=HTTP_400_BAD_REQUEST,
+            status_code=400,
             detail="VIEWER role not yet implemented",
         )
 
@@ -259,12 +250,12 @@ async def create_user(
             session.add(user)
     except (PostgreSQLIntegrityError, SQLiteIntegrityError) as e:
         if "users.username" in str(e):
-            raise HTTPException(status_code=HTTP_409_CONFLICT, detail="Username already exists")
+            raise HTTPException(status_code=409, detail="Username already exists")
         elif "users.email" in str(e):
-            raise HTTPException(status_code=HTTP_409_CONFLICT, detail="Email already exists")
+            raise HTTPException(status_code=409, detail="Email already exists")
         else:
             raise HTTPException(
-                status_code=HTTP_409_CONFLICT,
+                status_code=409,
                 detail="Failed to create user due to a conflict with existing data",
             )
     id_ = str(GlobalID("User", str(user.id)))
@@ -314,13 +305,13 @@ async def create_user(
     summary="Delete a user by ID",
     description="Delete an existing user by their unique GlobalID.",
     response_description="No content returned on successful deletion.",
-    status_code=HTTP_204_NO_CONTENT,
+    status_code=204,
     responses=add_errors_to_responses(
         [
-            {"status_code": HTTP_404_NOT_FOUND, "description": "User not found."},
-            HTTP_422_UNPROCESSABLE_ENTITY,
+            {"status_code": 404, "description": "User not found."},
+            422,
             {
-                "status_code": HTTP_403_FORBIDDEN,
+                "status_code": 403,
                 "description": "Cannot delete the default admin or system user",
             },
         ]

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

@@ -3,10 +3,6 @@ from typing import Any, Generic, Optional, TypedDict, TypeVar, Union
 from fastapi import HTTPException
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
-from starlette.status import (
-    HTTP_404_NOT_FOUND,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-)
 from strawberry.relay import GlobalID
 from typing_extensions import TypeAlias, assert_never
 
@@ -135,21 +131,21 @@ async def _get_project_by_identifier(
             name = project_identifier
         except HTTPException:
             raise HTTPException(
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                status_code=422,
                 detail=f"Invalid project identifier format: {project_identifier}",
             )
         stmt = select(models.Project).filter_by(name=name)
         project = await session.scalar(stmt)
         if project is None:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=f"Project with name {name} not found",
             )
     else:
         project = await session.get(models.Project, id_)
         if project is None:
             raise HTTPException(
-                status_code=HTTP_404_NOT_FOUND,
+                status_code=404,
                 detail=f"Project with ID {project_identifier} not found",
             )
     return project

phoenix/server/app.py

@@ -45,7 +45,6 @@ from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoin
 from starlette.requests import Request
 from starlette.responses import JSONResponse, PlainTextResponse, RedirectResponse, Response
 from starlette.staticfiles import StaticFiles
-from starlette.status import HTTP_401_UNAUTHORIZED
 from starlette.templating import Jinja2Templates
 from starlette.types import Scope, StatefulLifespan
 from strawberry.extensions import SchemaExtension
@@ -352,7 +351,7 @@ class RequestOriginHostnameValidator(BaseHTTPMiddleware):
             if not (url := headers.get(key)):
                 continue
             if urlparse(url).hostname not in self._trusted_hostnames:
-                return Response(f"untrusted {key}", status_code=HTTP_401_UNAUTHORIZED)
+                return Response(f"untrusted {key}", status_code=401)
         return await call_next(request)