arize-phoenix 8.22.1__py3-none-any.whl → 8.24.0__py3-none-any.whl

phoenix/server/api/mutations/user_mutations.py

@@ -1,3 +1,4 @@
+import logging
 import secrets
 from contextlib import AsyncExitStack
 from datetime import datetime, timezone
@@ -32,6 +33,8 @@ from phoenix.server.api.types.User import User, to_gql_user
 from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.types import AccessTokenId, ApiKeyId, PasswordResetTokenId, RefreshTokenId
 
+logger = logging.getLogger(__name__)
+
 
 @strawberry.input
 class CreateUserInput:
@@ -39,6 +42,7 @@ class CreateUserInput:
     username: str
     password: str
     role: UserRoleInput
+    send_welcome_email: Optional[bool] = False
 
 
 @strawberry.input
@@ -111,6 +115,12 @@ class UserMutationMixin:
                 await session.flush()
             except (PostgreSQLIntegrityError, SQLiteIntegrityError) as error:
                 raise Conflict(_user_operation_error_message(error))
+        if input.send_welcome_email and info.context.email_sender is not None:
+            try:
+                await info.context.email_sender.send_welcome_email(user.email, user.username)
+            except Exception as error:
+                # Log the error but do not raise it
+                logger.error(f"Failed to send welcome email: {error}")
         return UserMutationPayload(user=to_gql_user(user))
 
     @strawberry.mutation(permission_classes=[IsNotReadOnly, IsAdmin, IsLocked])  # type: ignore

phoenix/server/api/queries.py

@@ -19,7 +19,7 @@ from phoenix.config import (
     getenv,
 )
 from phoenix.db import enums, models
-from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.helpers import SupportedSQLDialect, exclude_experiment_projects
 from phoenix.db.models import DatasetExample as OrmExample
 from phoenix.db.models import DatasetExampleRevision as OrmRevision
 from phoenix.db.models import DatasetVersion as OrmVersion
@@ -42,7 +42,6 @@ from phoenix.server.api.input_types.ClusterInput import ClusterInput
 from phoenix.server.api.input_types.Coordinates import InputCoordinate2D, InputCoordinate3D
 from phoenix.server.api.input_types.DatasetSort import DatasetSort
 from phoenix.server.api.input_types.InvocationParameters import InvocationParameter
-from phoenix.server.api.subscriptions import PLAYGROUND_PROJECT_NAME
 from phoenix.server.api.types.Cluster import Cluster, to_gql_clusters
 from phoenix.server.api.types.Dataset import Dataset, to_gql_dataset
 from phoenix.server.api.types.DatasetExample import DatasetExample
@@ -233,18 +232,8 @@ class Query:
             last=last,
             before=before if isinstance(before, CursorString) else None,
         )
-        stmt = (
-            select(models.Project)
-            .outerjoin(
-                models.Experiment,
-                and_(
-                    models.Project.name == models.Experiment.project_name,
-                    models.Experiment.project_name != PLAYGROUND_PROJECT_NAME,
-                ),
-            )
-            .where(models.Experiment.project_name.is_(None))
-            .order_by(models.Project.id)
-        )
+        stmt = select(models.Project).order_by(models.Project.id)
+        stmt = exclude_experiment_projects(stmt)
         async with info.context.db() as session:
             projects = await session.stream_scalars(stmt)
             data = [

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

@@ -9,6 +9,7 @@ from .evaluations import router as evaluations_router
 from .experiment_evaluations import router as experiment_evaluations_router
 from .experiment_runs import router as experiment_runs_router
 from .experiments import router as experiments_router
+from .projects import router as projects_router
 from .prompts import router as prompts_router
 from .spans import router as spans_router
 from .traces import router as traces_router
@@ -63,4 +64,5 @@ def create_v1_router(authentication_enabled: bool) -> APIRouter:
     router.include_router(spans_router)
     router.include_router(evaluations_router)
     router.include_router(prompts_router)
+    router.include_router(projects_router)
     return router

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

@@ -0,0 +1,393 @@
+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,
+    HTTP_403_FORBIDDEN,
+    HTTP_404_NOT_FOUND,
+    HTTP_422_UNPROCESSABLE_ENTITY,
+)
+from strawberry.relay import GlobalID
+
+from phoenix.config import DEFAULT_PROJECT_NAME
+from phoenix.db import models
+from phoenix.db.enums import UserRole
+from phoenix.db.helpers import exclude_experiment_projects
+from phoenix.server.api.routers.v1.models import V1RoutesBaseModel
+from phoenix.server.api.routers.v1.utils import (
+    PaginatedResponseBody,
+    ResponseBody,
+    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"])
+
+
+class ProjectData(V1RoutesBaseModel):
+    name: str = Field(..., min_length=1)
+    description: Optional[str] = None
+
+
+class Project(ProjectData):
+    id: str
+
+
+class GetProjectsResponseBody(PaginatedResponseBody[Project]):
+    pass
+
+
+class GetProjectResponseBody(ResponseBody[Project]):
+    pass
+
+
+class CreateProjectRequestBody(ProjectData):
+    pass
+
+
+class CreateProjectResponseBody(ResponseBody[Project]):
+    pass
+
+
+class UpdateProjectRequestBody(V1RoutesBaseModel):
+    description: Optional[str] = None
+
+
+class UpdateProjectResponseBody(ResponseBody[Project]):
+    pass
+
+
+@router.get(
+    "/projects",
+    operation_id="getProjects",
+    summary="List all projects",  # noqa: E501
+    description="Retrieve a paginated list of all projects in the system.",  # noqa: E501
+    response_description="A list of projects with pagination information",  # noqa: E501
+    responses=add_errors_to_responses(
+        [
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+)
+async def get_projects(
+    request: Request,
+    cursor: Optional[str] = Query(
+        default=None,
+        description="Cursor for pagination (project ID)",
+    ),
+    limit: int = Query(
+        default=100, description="The max number of projects to return at a time.", gt=0
+    ),
+    include_experiment_projects: bool = Query(
+        default=False,
+        description="Include experiment projects in the response. Experiment projects are created from running experiments.",  # noqa: E501
+    ),
+) -> GetProjectsResponseBody:
+    """
+    Retrieve a paginated list of all projects in the system.
+
+    Args:
+        request (Request): The FastAPI request object.
+        cursor (Optional[str]): Pagination cursor (project ID).
+        limit (int): Maximum number of projects to return per request.
+        include_experiment_projects (bool): Flag to include experiment projects in the response.
+            Experiment projects are created from running experiments.
+
+    Returns:
+        GetProjectsResponseBody: Response containing a list of projects and pagination information.
+
+    Raises:
+        HTTPException: If the cursor format is invalid.
+    """  # noqa: E501
+    stmt = select(models.Project).order_by(models.Project.id.desc())
+    if not include_experiment_projects:
+        stmt = exclude_experiment_projects(stmt)
+    async with request.app.state.db() as session:
+        if cursor:
+            try:
+                cursor_id = GlobalID.from_id(cursor).node_id
+                stmt = stmt.filter(models.Project.id <= int(cursor_id))
+            except ValueError:
+                raise HTTPException(
+                    detail=f"Invalid cursor format: {cursor}",
+                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                )
+
+        stmt = stmt.limit(limit + 1)
+        projects = (await session.scalars(stmt)).all()
+
+        if not projects:
+            return GetProjectsResponseBody(next_cursor=None, data=[])
+
+        next_cursor = None
+        if len(projects) == limit + 1:
+            last_project = projects[-1]
+            next_cursor = str(GlobalID(ProjectNodeType.__name__, str(last_project.id)))
+            projects = projects[:-1]
+
+        project_responses = [_to_project_response(project) for project in projects]
+    return GetProjectsResponseBody(next_cursor=next_cursor, data=project_responses)
+
+
+@router.get(
+    "/projects/{project_identifier}",
+    operation_id="getProject",
+    summary="Get project by ID or name",  # noqa: E501
+    description="Retrieve a specific project using its unique identifier: either project ID or project name. Note: When using a project name as the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) characters.",  # noqa: E501
+    response_description="The requested project",  # noqa: E501
+    responses=add_errors_to_responses(
+        [
+            HTTP_404_NOT_FOUND,
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+)
+async def get_project(
+    request: Request,
+    project_identifier: str = Path(
+        description="The project identifier: either project ID or project name. If using a project name, it cannot contain slash (/), question mark (?), or pound sign (#) characters.",  # noqa: E501
+    ),
+) -> GetProjectResponseBody:
+    """
+    Retrieve a specific project by its ID or name.
+
+    Args:
+        request (Request): The FastAPI request object.
+        project_identifier (str): The project identifier: either project ID or project name.
+            If using a project name, it cannot contain slash (/), question mark (?), or pound sign (#) characters.
+
+    Returns:
+        GetProjectResponseBody: Response containing the requested project.
+
+    Raises:
+        HTTPException: If the project identifier format is invalid or the project is not found.
+    """  # noqa: E501
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+    data = _to_project_response(project)
+    return GetProjectResponseBody(data=data)
+
+
+@router.post(
+    "/projects",
+    operation_id="createProject",
+    summary="Create a new project",  # noqa: E501
+    description="Create a new project with the specified configuration.",  # noqa: E501
+    response_description="The newly created project",  # noqa: E501
+    responses=add_errors_to_responses(
+        [
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+)
+async def create_project(
+    request: Request,
+    request_body: CreateProjectRequestBody,
+) -> CreateProjectResponseBody:
+    """
+    Create a new project.
+
+    Args:
+        request (Request): The FastAPI request object.
+        request_body (CreateProjectRequestBody): The request body containing project data.
+
+    Returns:
+        CreateProjectResponseBody: Response containing the created project.
+
+    Raises:
+        HTTPException: If any validation error occurs.
+    """
+    async with request.app.state.db() as session:
+        project = models.Project(
+            name=request_body.name,
+            description=request_body.description,
+        )
+        session.add(project)
+        await session.flush()
+    data = _to_project_response(project)
+    return CreateProjectResponseBody(data=data)
+
+
+@router.put(
+    "/projects/{project_identifier}",
+    operation_id="updateProject",
+    summary="Update a project by ID or name",  # noqa: E501
+    description="Update an existing project with new configuration. Project names cannot be changed. The project identifier is either project ID or project name. Note: When using a project name as the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) characters.",  # noqa: E501
+    response_description="The updated project",  # noqa: E501
+    responses=add_errors_to_responses(
+        [
+            HTTP_403_FORBIDDEN,
+            HTTP_404_NOT_FOUND,
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+)
+async def update_project(
+    request: Request,
+    request_body: UpdateProjectRequestBody,
+    project_identifier: str = Path(
+        description="The project identifier: either project ID or project name. If using a project name, it cannot contain slash (/), question mark (?), or pound sign (#) characters.",  # noqa: E501
+    ),
+) -> UpdateProjectResponseBody:
+    """
+    Update an existing project.
+
+    Args:
+        request (Request): The FastAPI request object.
+        request_body (UpdateProjectRequestBody): The request body containing the new description.
+        project_identifier (str): The project identifier: either project ID or project name.
+            If using a project name, it cannot contain slash (/), question mark (?), or pound sign (#) characters.
+
+    Returns:
+        UpdateProjectResponseBody: Response containing the updated project.
+
+    Raises:
+        HTTPException: If the project identifier format is invalid or the project is not found.
+    """  # noqa: E501
+    if request.app.state.authentication_enabled:
+        async with request.app.state.db() as session:
+            # Check if the user is an admin
+            stmt = (
+                select(models.UserRole.name)
+                .join(models.User)
+                .where(models.User.id == int(request.user.identity))
+            )
+            role_name = await session.scalar(stmt)
+        if role_name != UserRole.ADMIN.value:
+            raise HTTPException(
+                status_code=HTTP_403_FORBIDDEN,
+                detail="Only admins can update projects",
+            )
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+
+        # Update the description if provided
+        if request_body.description is not None:
+            project.description = request_body.description
+
+    data = _to_project_response(project)
+    return UpdateProjectResponseBody(data=data)
+
+
+@router.delete(
+    "/projects/{project_identifier}",
+    operation_id="deleteProject",
+    summary="Delete a project by ID or name",  # noqa: E501
+    description="Delete an existing project and all its associated data. The project identifier is either project ID or project name. The default project cannot be deleted. Note: When using a project name as the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) characters.",  # noqa: E501
+    response_description="No content returned on successful deletion",  # noqa: E501
+    status_code=HTTP_204_NO_CONTENT,
+    responses=add_errors_to_responses(
+        [
+            HTTP_403_FORBIDDEN,
+            HTTP_404_NOT_FOUND,
+            HTTP_422_UNPROCESSABLE_ENTITY,
+        ]
+    ),
+)
+async def delete_project(
+    request: Request,
+    project_identifier: str = Path(
+        description="The project identifier: either project ID or project name. If using a project name, it cannot contain slash (/), question mark (?), or pound sign (#) characters.",  # noqa: E501
+    ),
+) -> None:
+    """
+    Delete an existing project.
+
+    Args:
+        request (Request): The FastAPI request object.
+        project_identifier (str): The project identifier: either project ID or project name.
+            If using a project name, it cannot contain slash (/), question mark (?), or pound sign (#) characters.
+
+    Returns:
+        None: Returns a 204 No Content response on success.
+
+    Raises:
+        HTTPException: If the project identifier format is invalid, the project is not found, or it's the default project.
+    """  # noqa: E501
+    if request.app.state.authentication_enabled:
+        async with request.app.state.db() as session:
+            # Check if the user is an admin
+            stmt = (
+                select(models.UserRole.name)
+                .join(models.User)
+                .where(models.User.id == int(request.user.identity))
+            )
+            role_name = await session.scalar(stmt)
+        if role_name != UserRole.ADMIN.value:
+            raise HTTPException(
+                status_code=HTTP_403_FORBIDDEN,
+                detail="Only admins can delete projects",
+            )
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+
+        # The default project must not be deleted - it's forbidden
+        if project.name == DEFAULT_PROJECT_NAME:
+            raise HTTPException(
+                status_code=HTTP_403_FORBIDDEN,
+                detail="The default project cannot be deleted",
+            )
+
+        await session.delete(project)
+    return None
+
+
+def _to_project_response(project: models.Project) -> Project:
+    return Project(
+        id=str(GlobalID(ProjectNodeType.__name__, str(project.id))),
+        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

phoenix/server/api/subscriptions.py

@@ -23,6 +23,7 @@ from strawberry.relay.types import GlobalID
 from strawberry.types import Info
 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.server.api.auth import IsLocked, IsNotReadOnly
@@ -84,7 +85,6 @@ ChatCompletionResult: TypeAlias = tuple[
     DatasetExampleID, Optional[models.Span], models.ExperimentRun
 ]
 ChatStream: TypeAlias = AsyncGenerator[ChatCompletionSubscriptionPayload, None]
-PLAYGROUND_PROJECT_NAME = "playground"
 
 
 @strawberry.type

phoenix/server/app.py

@@ -24,6 +24,7 @@ from urllib.parse import urlparse
 
 import strawberry
 from fastapi import APIRouter, Depends, FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.utils import is_body_allowed_for_status_code
 from grpc.aio import ServerInterceptor
@@ -59,6 +60,7 @@ from phoenix.config import (
     get_env_host,
     get_env_port,
     server_instrumentation_is_enabled,
+    verify_server_environment_variables,
 )
 from phoenix.core.model_schema import Model
 from phoenix.db import models
@@ -550,6 +552,7 @@ def create_graphql_router(
     read_only: bool = False,
     secret: Optional[str] = None,
     token_store: Optional[TokenStore] = None,
+    email_sender: Optional[EmailSender] = None,
 ) -> GraphQLRouter[Context, None]:
     """Creates the GraphQL router.
 
@@ -565,6 +568,8 @@ def create_graphql_router(
         cache_for_dataloaders (Optional[CacheForDataLoaders], optional): GraphQL data loaders.
         read_only (bool, optional): Marks the app as read-only. Defaults to False.
         secret (Optional[str], optional): The application secret for auth. Defaults to None.
+        token_store (Optional[TokenStore], optional): The token store for auth. Defaults to None.
+        email_sender (Optional[EmailSender], optional): The email sender. Defaults to None.
 
     Returns:
         GraphQLRouter: The router mounted at /graphql
@@ -653,6 +658,7 @@ def create_graphql_router(
             auth_enabled=authentication_enabled,
             secret=secret,
             token_store=token_store,
+            email_sender=email_sender,
         )
 
     return GraphQLRouter(
@@ -765,7 +771,9 @@ def create_app(
     email_sender: Optional[EmailSender] = None,
     oauth2_client_configs: Optional[list[OAuth2ClientConfig]] = None,
     bulk_inserter_factory: Optional[Callable[..., BulkInserter]] = None,
+    allowed_origins: Optional[list[str]] = None,
 ) -> FastAPI:
+    verify_server_environment_variables()
     if model.embedding_dimensions:
         try:
             import fast_hdbscan  # noqa: F401
@@ -868,6 +876,7 @@ def create_app(
         read_only=read_only,
         secret=secret,
         token_store=token_store,
+        email_sender=email_sender,
     )
     if enable_prometheus:
         from phoenix.server.prometheus import PrometheusMiddleware
@@ -948,6 +957,14 @@ def create_app(
         FastAPIInstrumentor().instrument(tracer_provider=tracer_provider)
         FastAPIInstrumentor.instrument_app(app, tracer_provider=tracer_provider)
         shutdown_callbacks_list.append(FastAPIInstrumentor().uninstrument)
+    if allowed_origins:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=allowed_origins,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
     return app