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

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

@@ -0,0 +1,449 @@
+import logging
+from typing import Annotated, List, Literal, Optional, Union
+
+from fastapi import APIRouter, HTTPException, Path, Query
+from pydantic import Field, RootModel
+from sqlalchemy import delete, select
+from sqlalchemy.exc import IntegrityError as PostgreSQLIntegrityError
+from sqlean.dbapi2 import IntegrityError as SQLiteIntegrityError  # type: ignore[import-untyped]
+from starlette.requests import Request
+from starlette.status import (
+    HTTP_400_BAD_REQUEST,
+    HTTP_404_NOT_FOUND,
+    HTTP_409_CONFLICT,
+)
+from strawberry.relay import GlobalID
+from typing_extensions import TypeAlias, assert_never
+
+from phoenix.db import models
+from phoenix.db.types.annotation_configs import (
+    AnnotationConfigType,
+    AnnotationType,
+    OptimizationDirection,
+)
+from phoenix.db.types.annotation_configs import (
+    CategoricalAnnotationConfig as CategoricalAnnotationConfigModel,
+)
+from phoenix.db.types.annotation_configs import (
+    CategoricalAnnotationValue as CategoricalAnnotationValueModel,
+)
+from phoenix.db.types.annotation_configs import (
+    ContinuousAnnotationConfig as ContinuousAnnotationConfigModel,
+)
+from phoenix.db.types.annotation_configs import (
+    FreeformAnnotationConfig as FreeformAnnotationConfigModel,
+)
+from phoenix.server.api.routers.v1.models import V1RoutesBaseModel
+from phoenix.server.api.routers.v1.utils import PaginatedResponseBody, ResponseBody
+from phoenix.server.api.types.AnnotationConfig import (
+    CategoricalAnnotationConfig as CategoricalAnnotationConfigType,
+)
+from phoenix.server.api.types.AnnotationConfig import (
+    ContinuousAnnotationConfig as ContinuousAnnotationConfigType,
+)
+from phoenix.server.api.types.AnnotationConfig import (
+    FreeformAnnotationConfig as FreeformAnnotationConfigType,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["annotation_configs"])
+
+
+class CategoricalAnnotationValue(V1RoutesBaseModel):
+    label: str
+    score: Optional[float] = None
+
+
+class CategoricalAnnotationConfigData(V1RoutesBaseModel):
+    name: str
+    type: Literal[AnnotationType.CATEGORICAL.value]  # type: ignore[name-defined]
+    description: Optional[str] = None
+    optimization_direction: OptimizationDirection
+    values: List[CategoricalAnnotationValue]
+
+
+class ContinuousAnnotationConfigData(V1RoutesBaseModel):
+    name: str
+    type: Literal[AnnotationType.CONTINUOUS.value]  # type: ignore[name-defined]
+    description: Optional[str] = None
+    optimization_direction: OptimizationDirection
+    lower_bound: Optional[float] = None
+    upper_bound: Optional[float] = None
+
+
+class FreeformAnnotationConfigData(V1RoutesBaseModel):
+    name: str
+    type: Literal[AnnotationType.FREEFORM.value]  # type: ignore[name-defined]
+    description: Optional[str] = None
+
+
+AnnotationConfigData: TypeAlias = Annotated[
+    Union[
+        CategoricalAnnotationConfigData,
+        ContinuousAnnotationConfigData,
+        FreeformAnnotationConfigData,
+    ],
+    Field(..., discriminator="type"),
+]
+
+
+class CategoricalAnnotationConfig(CategoricalAnnotationConfigData):
+    id: str
+
+
+class ContinuousAnnotationConfig(ContinuousAnnotationConfigData):
+    id: str
+
+
+class FreeformAnnotationConfig(FreeformAnnotationConfigData):
+    id: str
+
+
+AnnotationConfig: TypeAlias = Annotated[
+    Union[
+        CategoricalAnnotationConfig,
+        ContinuousAnnotationConfig,
+        FreeformAnnotationConfig,
+    ],
+    Field(..., discriminator="type"),
+]
+
+
+def db_to_api_annotation_config(
+    annotation_config: models.AnnotationConfig,
+) -> AnnotationConfig:
+    config = annotation_config.config
+    name = annotation_config.name
+    type_ = config.type
+    description = config.description
+    if isinstance(config, ContinuousAnnotationConfigModel):
+        return ContinuousAnnotationConfig(
+            id=str(GlobalID(ContinuousAnnotationConfigType.__name__, str(annotation_config.id))),
+            name=name,
+            type=type_,
+            description=description,
+            optimization_direction=config.optimization_direction,
+            lower_bound=config.lower_bound,
+            upper_bound=config.upper_bound,
+        )
+    if isinstance(config, CategoricalAnnotationConfigModel):
+        return CategoricalAnnotationConfig(
+            id=str(GlobalID(CategoricalAnnotationConfigType.__name__, str(annotation_config.id))),
+            name=name,
+            type=type_,
+            description=description,
+            optimization_direction=config.optimization_direction,
+            values=[
+                CategoricalAnnotationValue(label=val.label, score=val.score)
+                for val in config.values
+            ],
+        )
+    if isinstance(config, FreeformAnnotationConfigModel):
+        return FreeformAnnotationConfig(
+            id=str(GlobalID(FreeformAnnotationConfigType.__name__, str(annotation_config.id))),
+            name=name,
+            type=type_,
+            description=description,
+        )
+    assert_never(config)
+
+
+def _get_annotation_global_id(annotation_config: models.AnnotationConfig) -> GlobalID:
+    config = annotation_config.config
+    if isinstance(config, ContinuousAnnotationConfigModel):
+        return GlobalID(ContinuousAnnotationConfigType.__name__, str(annotation_config.id))
+    if isinstance(config, CategoricalAnnotationConfigModel):
+        return GlobalID(CategoricalAnnotationConfigType.__name__, str(annotation_config.id))
+    if isinstance(config, FreeformAnnotationConfigModel):
+        return GlobalID(FreeformAnnotationConfigType.__name__, str(annotation_config.id))
+    assert_never(config)
+
+
+class CreateAnnotationConfigData(RootModel[AnnotationConfigData]):
+    root: AnnotationConfigData
+
+
+class GetAnnotationConfigsResponseBody(PaginatedResponseBody[AnnotationConfig]):
+    pass
+
+
+class GetAnnotationConfigResponseBody(ResponseBody[AnnotationConfig]):
+    pass
+
+
+class CreateAnnotationConfigResponseBody(ResponseBody[AnnotationConfig]):
+    pass
+
+
+class UpdateAnnotationConfigResponseBody(ResponseBody[AnnotationConfig]):
+    pass
+
+
+class DeleteAnnotationConfigResponseBody(ResponseBody[AnnotationConfig]):
+    pass
+
+
+@router.get(
+    "/annotation_configs",
+    summary="List annotation configurations",
+    description="Retrieve a paginated list of all annotation configurations in the system.",
+    response_description="A list of annotation configurations with pagination information",
+)
+async def list_annotation_configs(
+    request: Request,
+    cursor: Optional[str] = Query(
+        default=None,
+        description="Cursor for pagination (base64-encoded annotation config ID)",
+    ),
+    limit: int = Query(100, gt=0, description="Maximum number of configs to return"),
+) -> GetAnnotationConfigsResponseBody:
+    cursor_id: Optional[int] = None
+    if cursor:
+        try:
+            cursor_gid = GlobalID.from_id(cursor)
+        except ValueError:
+            raise HTTPException(
+                detail=f"Invalid cursor: {cursor}",
+                status_code=HTTP_400_BAD_REQUEST,
+            )
+        if cursor_gid.type_name not in (
+            CategoricalAnnotationConfigType.__name__,
+            ContinuousAnnotationConfigType.__name__,
+            FreeformAnnotationConfigType.__name__,
+        ):
+            raise HTTPException(
+                detail=f"Invalid cursor: {cursor}",
+                status_code=HTTP_400_BAD_REQUEST,
+            )
+        cursor_id = int(cursor_gid.node_id)
+
+    async with request.app.state.db() as session:
+        query = (
+            select(models.AnnotationConfig)
+            .order_by(models.AnnotationConfig.id.desc())
+            .limit(limit + 1)  # overfetch by 1 to check if there are more results
+        )
+        if cursor_id is not None:
+            query = query.where(models.AnnotationConfig.id <= cursor_id)
+
+        result = await session.scalars(query)
+        configs = result.all()
+
+        next_cursor = None
+        if len(configs) == limit + 1:
+            last_config = configs[-1]
+            next_cursor = str(_get_annotation_global_id(last_config))
+            configs = configs[:-1]
+
+        return GetAnnotationConfigsResponseBody(
+            next_cursor=next_cursor,
+            data=[db_to_api_annotation_config(config) for config in configs],
+        )
+
+
+@router.get(
+    "/annotation_configs/{config_identifier}",
+    summary="Get an annotation configuration by ID or name",
+)
+async def get_annotation_config_by_name_or_id(
+    request: Request,
+    config_identifier: str = Path(..., description="ID or name of the annotation configuration"),
+) -> GetAnnotationConfigResponseBody:
+    async with request.app.state.db() as session:
+        query = select(models.AnnotationConfig)
+        # Try to interpret the identifier as an integer ID; if not, use it as a name.
+        try:
+            db_id = _get_annotation_config_db_id(config_identifier)
+            query = query.where(models.AnnotationConfig.id == db_id)
+        except ValueError:
+            query = query.where(models.AnnotationConfig.name == config_identifier)
+        config = await session.scalar(query)
+        if not config:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND, detail="Annotation configuration not found"
+            )
+        return GetAnnotationConfigResponseBody(data=db_to_api_annotation_config(config))
+
+
+@router.post(
+    "/annotation_configs",
+    summary="Create an annotation configuration",
+)
+async def create_annotation_config(
+    request: Request,
+    data: CreateAnnotationConfigData,
+) -> CreateAnnotationConfigResponseBody:
+    input_config = data.root
+    _reserve_note_annotation_name(input_config)
+
+    try:
+        db_config = _to_db_annotation_config(input_config)
+    except ValueError as error:
+        raise HTTPException(status_code=HTTP_400_BAD_REQUEST, detail=str(error))
+
+    async with request.app.state.db() as session:
+        annotation_config = models.AnnotationConfig(
+            name=input_config.name,
+            config=db_config,
+        )
+        session.add(annotation_config)
+        try:
+            await session.commit()
+        except (PostgreSQLIntegrityError, SQLiteIntegrityError):
+            raise HTTPException(
+                status_code=HTTP_409_CONFLICT,
+                detail="The name of the annotation configuration is already taken",
+            )
+        return CreateAnnotationConfigResponseBody(
+            data=db_to_api_annotation_config(annotation_config)
+        )
+
+
+@router.put(
+    "/annotation_configs/{config_id}",
+    summary="Update an annotation configuration",
+)
+async def update_annotation_config(
+    request: Request,
+    data: CreateAnnotationConfigData,
+    config_id: str = Path(..., description="ID of the annotation configuration"),
+) -> UpdateAnnotationConfigResponseBody:
+    input_config = data.root
+    _reserve_note_annotation_name(input_config)
+
+    config_gid = GlobalID.from_id(config_id)
+    if config_gid.type_name not in (
+        CategoricalAnnotationConfigType.__name__,
+        ContinuousAnnotationConfigType.__name__,
+        FreeformAnnotationConfigType.__name__,
+    ):
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST, detail="Invalid annotation configuration ID"
+        )
+    config_rowid = int(config_gid.node_id)
+
+    try:
+        db_config = _to_db_annotation_config(input_config)
+    except ValueError as error:
+        raise HTTPException(status_code=HTTP_400_BAD_REQUEST, detail=str(error))
+
+    async with request.app.state.db() as session:
+        existing_config = await session.get(models.AnnotationConfig, config_rowid)
+        if not existing_config:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND, detail="Annotation configuration not found"
+            )
+
+        existing_config.name = input_config.name
+        existing_config.config = db_config
+
+        try:
+            await session.commit()
+        except (PostgreSQLIntegrityError, SQLiteIntegrityError):
+            raise HTTPException(
+                status_code=HTTP_409_CONFLICT,
+                detail="The name of the annotation configuration is already taken",
+            )
+
+        return UpdateAnnotationConfigResponseBody(data=db_to_api_annotation_config(existing_config))
+
+
+@router.delete(
+    "/annotation_configs/{config_id}",
+    summary="Delete an annotation configuration",
+)
+async def delete_annotation_config(
+    request: Request,
+    config_id: str = Path(..., description="ID of the annotation configuration"),
+) -> DeleteAnnotationConfigResponseBody:
+    config_gid = GlobalID.from_id(config_id)
+    if config_gid.type_name not in (
+        CategoricalAnnotationConfigType.__name__,
+        ContinuousAnnotationConfigType.__name__,
+        FreeformAnnotationConfigType.__name__,
+    ):
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST, detail="Invalid annotation configuration ID"
+        )
+    config_rowid = int(config_gid.node_id)
+    async with request.app.state.db() as session:
+        stmt = (
+            delete(models.AnnotationConfig)
+            .where(models.AnnotationConfig.id == config_rowid)
+            .returning(models.AnnotationConfig)
+        )
+        annotation_config = await session.scalar(stmt)
+        if annotation_config is None:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND, detail="Annotation configuration not found"
+            )
+        await session.commit()
+    return DeleteAnnotationConfigResponseBody(data=db_to_api_annotation_config(annotation_config))
+
+
+def _get_annotation_config_db_id(config_gid: str) -> int:
+    gid = GlobalID.from_id(config_gid)
+    type_name, node_id = gid.type_name, int(gid.node_id)
+    if type_name not in (
+        CategoricalAnnotationConfigType.__name__,
+        ContinuousAnnotationConfigType.__name__,
+        FreeformAnnotationConfigType.__name__,
+    ):
+        raise ValueError(f"Invalid annotation configuration ID: {config_gid}")
+    return node_id
+
+
+def _reserve_note_annotation_name(data: AnnotationConfigData) -> str:
+    name = data.name
+    if name == "note":
+        raise HTTPException(
+            status_code=HTTP_409_CONFLICT, detail="The name 'note' is reserved for span notes"
+        )
+    return name
+
+
+def _to_db_annotation_config(input_config: AnnotationConfigData) -> AnnotationConfigType:
+    if isinstance(input_config, ContinuousAnnotationConfigData):
+        return _to_db_continuous_annotation_config(input_config)
+    if isinstance(input_config, CategoricalAnnotationConfigData):
+        return _to_db_categorical_annotation_config(input_config)
+    if isinstance(input_config, FreeformAnnotationConfigData):
+        return _to_db_freeform_annotation_config(input_config)
+    assert_never(input_config)
+
+
+def _to_db_continuous_annotation_config(
+    input_config: ContinuousAnnotationConfigData,
+) -> ContinuousAnnotationConfigModel:
+    return ContinuousAnnotationConfigModel(
+        type=AnnotationType.CONTINUOUS.value,
+        description=input_config.description,
+        optimization_direction=input_config.optimization_direction,
+        lower_bound=input_config.lower_bound,
+        upper_bound=input_config.upper_bound,
+    )
+
+
+def _to_db_categorical_annotation_config(
+    input_config: CategoricalAnnotationConfigData,
+) -> CategoricalAnnotationConfigModel:
+    values = [
+        CategoricalAnnotationValueModel(label=value.label, score=value.score)
+        for value in input_config.values
+    ]
+    return CategoricalAnnotationConfigModel(
+        type=AnnotationType.CATEGORICAL.value,
+        description=input_config.description,
+        optimization_direction=input_config.optimization_direction,
+        values=values,
+    )
+
+
+def _to_db_freeform_annotation_config(
+    input_config: FreeformAnnotationConfigData,
+) -> FreeformAnnotationConfigModel:
+    return FreeformAnnotationConfigModel(
+        type=AnnotationType.FREEFORM.value,
+        description=input_config.description,
+    )

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

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Literal, Optional
+
+from fastapi import APIRouter, HTTPException, Path, Query
+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
+from phoenix.server.api.types.SpanAnnotation import SpanAnnotation as SpanAnnotationNodeType
+from phoenix.server.api.types.User import User as UserNodeType
+
+from .spans import SpanAnnotationData, SpanAnnotationResult
+from .utils import PaginatedResponseBody, _get_project_by_identifier, add_errors_to_responses
+
+logger = logging.getLogger(__name__)
+
+SPAN_ANNOTATION_NODE_NAME = SpanAnnotationNodeType.__name__
+USER_NODE_NAME = UserNodeType.__name__
+MAX_SPAN_IDS = 1_000
+
+router = APIRouter(tags=["annotations"])
+
+
+class SpanAnnotation(SpanAnnotationData):
+    id: str
+    created_at: datetime
+    updated_at: datetime
+    source: Literal["API", "APP"]
+    user_id: Optional[str]
+
+
+class SpanAnnotationsResponseBody(PaginatedResponseBody[SpanAnnotation]):
+    pass
+
+
+@router.get(
+    "/projects/{project_identifier}/span_annotations",
+    operation_id="listSpanAnnotationsBySpanIds",
+    summary="Get span annotations for a list of span_ids.",
+    status_code=HTTP_200_OK,
+    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"},
+        ]
+    ),
+)
+async def list_span_annotations(
+    request: Request,
+    project_identifier: str = Path(
+        description=(
+            "The project identifier: either project ID or project name. If using a project name as "
+            "the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) "
+            "characters."
+        )
+    ),
+    span_ids: list[str] = Query(
+        ..., min_length=1, description="One or more span id to fetch annotations for"
+    ),
+    cursor: Optional[str] = Query(default=None, description="A cursor for pagination"),
+    limit: int = Query(
+        default=10,
+        gt=0,
+        le=10000,
+        description="The maximum number of annotations to return in a single request",
+    ),
+) -> SpanAnnotationsResponseBody:
+    span_ids = list({*span_ids})
+    if len(span_ids) > MAX_SPAN_IDS:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Too many span_ids supplied: {len(span_ids)} (max {MAX_SPAN_IDS})",
+        )
+
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+        if not project:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Project with identifier {project_identifier} not found",
+            )
+        stmt = (
+            select(models.Span.span_id, models.SpanAnnotation)
+            .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
+            .join(models.Project, models.Trace.project_rowid == models.Project.id)
+            .join(models.SpanAnnotation, models.SpanAnnotation.span_rowid == models.Span.id)
+            .where(
+                models.Project.id == project.id,
+                models.Span.span_id.in_(span_ids),
+            )
+            .order_by(models.SpanAnnotation.id.desc())
+            .limit(limit + 1)
+        )
+
+        if cursor:
+            try:
+                cursor_id = int(GlobalID.from_id(cursor).node_id)
+            except ValueError:
+                raise HTTPException(
+                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail="Invalid cursor value",
+                )
+            stmt = stmt.where(models.SpanAnnotation.id <= cursor_id)
+
+        rows: list[tuple[str, models.SpanAnnotation]] = [
+            r async for r in (await session.stream(stmt))
+        ]
+
+        next_cursor: Optional[str] = None
+        if len(rows) == limit + 1:
+            *rows, extra = rows
+            next_cursor = str(GlobalID(SPAN_ANNOTATION_NODE_NAME, str(extra[1].id)))
+
+        if not rows:
+            spans_exist = await session.scalar(
+                select(
+                    exists().where(
+                        models.Span.span_id.in_(span_ids),
+                        models.Span.trace_rowid.in_(
+                            select(models.Trace.id)
+                            .join(models.Project)
+                            .where(models.Project.id == project.id)
+                        ),
+                    )
+                )
+            )
+            if not spans_exist:
+                raise HTTPException(
+                    detail="None of the supplied span_ids exist in this project",
+                    status_code=HTTP_404_NOT_FOUND,
+                )
+
+            return SpanAnnotationsResponseBody(data=[], next_cursor=None)
+
+        data = [
+            SpanAnnotation(
+                id=str(GlobalID(SPAN_ANNOTATION_NODE_NAME, str(anno.id))),
+                span_id=span_id,
+                name=anno.name,
+                result=SpanAnnotationResult(
+                    label=anno.label,
+                    score=anno.score,
+                    explanation=anno.explanation,
+                ),
+                metadata=anno.metadata_,
+                annotator_kind=anno.annotator_kind,
+                created_at=anno.created_at,
+                updated_at=anno.updated_at,
+                identifier=anno.identifier,
+                source=anno.source,
+                user_id=str(GlobalID(USER_NODE_NAME, str(anno.user_id))) if anno.user_id else None,
+            )
+            for span_id, anno in rows
+        ]
+
+    return SpanAnnotationsResponseBody(data=data, next_cursor=next_cursor)

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

@@ -211,6 +211,8 @@ async def _add_evaluations(state: State, evaluations: Evaluations) -> None:
             score, label, explanation = _get_annotation_result(row)
             document_annotation = cls(cast(Union[tuple[str, int], tuple[int, str]], index))(
                 name=eval_name,
+                identifier="",
+                source="API",
                 annotator_kind="LLM",
                 score=score,
                 label=label,
@@ -223,6 +225,8 @@ async def _add_evaluations(state: State, evaluations: Evaluations) -> None:
             score, label, explanation = _get_annotation_result(row)
             span_annotation = _span_annotation_factory(cast(str, index))(
                 name=eval_name,
+                identifier="",
+                source="API",
                 annotator_kind="LLM",
                 score=score,
                 label=label,
@@ -235,6 +239,8 @@ async def _add_evaluations(state: State, evaluations: Evaluations) -> None:
             score, label, explanation = _get_annotation_result(row)
             trace_annotation = _trace_annotation_factory(cast(str, index))(
                 name=eval_name,
+                identifier="",
+                source="API",
                 annotator_kind="LLM",
                 score=score,
                 label=label,

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

@@ -3,7 +3,6 @@ from typing import Optional
 from fastapi import APIRouter, HTTPException, Path, Query
 from pydantic import Field
 from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
 from starlette.requests import Request
 from starlette.status import (
     HTTP_204_NO_CONTENT,
@@ -21,9 +20,9 @@ from phoenix.server.api.routers.v1.models import V1RoutesBaseModel
 from phoenix.server.api.routers.v1.utils import (
     PaginatedResponseBody,
     ResponseBody,
+    _get_project_by_identifier,
     add_errors_to_responses,
 )
-from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.Project import Project as ProjectNodeType
 
 router = APIRouter(tags=["projects"])
@@ -343,51 +342,3 @@ def _to_project_response(project: models.Project) -> Project:
         name=project.name,
         description=project.description,
     )
-
-
-async def _get_project_by_identifier(
-    session: AsyncSession,
-    project_identifier: str,
-) -> models.Project:
-    """
-    Get a project by its ID or name.
-
-    Args:
-        session: The database session.
-        project_identifier: The project ID or name.
-
-    Returns:
-        The project object.
-
-    Raises:
-        HTTPException: If the identifier format is invalid or the project is not found.
-    """
-    # Try to parse as a GlobalID first
-    try:
-        id_ = from_global_id_with_expected_type(
-            GlobalID.from_id(project_identifier),
-            ProjectNodeType.__name__,
-        )
-    except Exception:
-        try:
-            name = project_identifier
-        except HTTPException:
-            raise HTTPException(
-                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-                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,
-                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,
-                detail=f"Project with ID {project_identifier} not found",
-            )
-    return project