arize-phoenix 8.23.0__tar.gz → 8.24.1__tar.gz

{arize_phoenix-8.23.0 → arize_phoenix-8.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 8.23.0
+Version: 8.24.1
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-8.23.0 → arize_phoenix-8.24.1}/src/phoenix/config.py

@@ -8,10 +8,11 @@ from enum import Enum
 from importlib.metadata import version
 from pathlib import Path
 from typing import Any, Optional, Union, cast, overload
-from urllib.parse import quote_plus, urlparse
+from urllib.parse import quote_plus, urljoin, urlparse
 
 import wrapt
 from email_validator import EmailNotValidError, validate_email
+from starlette.datastructures import URL
 
 from phoenix.utilities.logging import log_a_list
 
@@ -182,6 +183,19 @@ If the username or email address already exists in the database, the user record
 modified, e.g., changed from non-admin to admin. Changing this environment variable for the next
 startup will not undo any records created in previous startups.
 """
+ENV_PHOENIX_ROOT_URL = "PHOENIX_ROOT_URL"
+"""
+This is the full URL used to access Phoenix from a web browser. This setting is important when
+you have a reverse proxy in front of Phoenix. If the reverse proxy exposes Phoenix through a
+sub-path, add that sub-path to the end of this URL setting.
+
+WARNING: When a sub-path is needed, you must also specify the sub-path via the environment
+variable PHOENIX_HOST_ROOT_PATH. Setting just this URL setting is not enough.
+
+Examples:
+    - With a sub-path: "https://example.com/phoenix"
+    - Without a sub-path: "https://phoenix.example.com"
+"""
 
 
 # SMTP settings
@@ -828,7 +842,7 @@ def get_env_host() -> str:
 
 
 def get_env_host_root_path() -> str:
-    if (host_root_path := getenv(ENV_PHOENIX_HOST_ROOT_PATH)) is None:
+    if not (host_root_path := getenv(ENV_PHOENIX_HOST_ROOT_PATH)):
         return HOST_ROOT_PATH
     if not host_root_path.startswith("/"):
         raise ValueError(
@@ -894,7 +908,33 @@ def get_env_client_headers() -> dict[str, str]:
     return headers
 
 
+def get_env_root_url() -> URL:
+    """
+    Get the URL used to access Phoenix from a web browser
+
+    Returns:
+        URL: The root URL of the Phoenix server
+
+    Note:
+        This is intended to replace the legacy `get_base_url()` helper function. In
+        particular, `get_env_collector_endpoint()` is really for the client and should be
+        deprecated on the server side.
+    """
+    if root_url := getenv(ENV_PHOENIX_ROOT_URL):
+        result = urlparse(root_url)
+        if not result.scheme or not result.netloc:
+            raise ValueError(
+                f"The environment variable `{ENV_PHOENIX_ROOT_URL}` must be a valid URL."
+            )
+        return URL(root_url)
+    host = get_env_host()
+    if host == "0.0.0.0":
+        host = "127.0.0.1"
+    return URL(urljoin(f"http://{host}:{get_env_port()}", get_env_host_root_path()))
+
+
 def get_base_url() -> str:
+    """Deprecated: Use get_env_root_url() instead, but note the difference in behavior."""
     host = get_env_host()
     if host == "0.0.0.0":
         host = "127.0.0.1"
@@ -1065,4 +1105,10 @@ def get_env_allowed_origins() -> Optional[list[str]]:
     return allowed_origins.split(",")
 
 
+def verify_server_environment_variables() -> None:
+    """Verify that the environment variables are set correctly. Raises an error otherwise."""
+    get_env_root_url()
+
+
 SKLEARN_VERSION = cast(tuple[int, int], tuple(map(int, version("scikit-learn").split(".", 2)[:2])))
+PLAYGROUND_PROJECT_NAME = "playground"

arize_phoenix-8.24.1/src/phoenix/db/facilitator.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import secrets
+from asyncio import gather
+from functools import partial
+from typing import Optional
+
+from sqlalchemy import (
+    distinct,
+    insert,
+    select,
+)
+
+from phoenix.auth import (
+    DEFAULT_ADMIN_EMAIL,
+    DEFAULT_ADMIN_USERNAME,
+    DEFAULT_SECRET_LENGTH,
+    DEFAULT_SYSTEM_EMAIL,
+    DEFAULT_SYSTEM_USERNAME,
+    compute_password_hash,
+)
+from phoenix.config import (
+    get_env_admins,
+    get_env_default_admin_initial_password,
+)
+from phoenix.db import models
+from phoenix.db.enums import COLUMN_ENUMS, UserRole
+from phoenix.server.email.types import WelcomeEmailSender
+from phoenix.server.types import DbSessionFactory
+
+logger = logging.getLogger(__name__)
+
+
+class Facilitator:
+    """
+    Facilitates the creation of database records necessary for Phoenix to function. This includes
+    ensuring that all enum values are present in their respective tables, ensuring that all user
+    roles are present, and ensuring that the admin user has a password hash. These tasks will be
+    carried out as callbacks at the very beginning of Starlette's lifespan process.
+    """
+
+    def __init__(
+        self,
+        *,
+        db: DbSessionFactory,
+        email_sender: Optional[WelcomeEmailSender] = None,
+    ) -> None:
+        self._db = db
+        self._email_sender = email_sender
+
+    async def __call__(self) -> None:
+        for fn in (
+            _ensure_enums,
+            _ensure_user_roles,
+            partial(_ensure_admins, email_sender=self._email_sender),
+        ):
+            await fn(self._db)
+
+
+async def _ensure_enums(db: DbSessionFactory) -> None:
+    """
+    Ensure that all enum values are present in their respective tables. If any values are missing,
+    they will be added. If any values are present in the database but not in the enum, an error will
+    be raised. This function is idempotent: it will not add duplicate values to the database.
+    """
+    for column, enum in COLUMN_ENUMS.items():
+        table = column.class_
+        async with db() as session:
+            existing = set(
+                [_ async for _ in await session.stream_scalars(select(distinct(column)))]
+            )
+            expected = set(e.value for e in enum)
+            if unexpected := existing - expected:
+                raise ValueError(f"Unexpected values in {table.name}.{column.key}: {unexpected}")
+            if not (missing := expected - existing):
+                continue
+            await session.execute(insert(table), [{column.key: v} for v in missing])
+
+
+async def _ensure_user_roles(db: DbSessionFactory) -> None:
+    """
+    Ensure that the system and admin roles are present in the database. If they are not, they will
+    be added. The system user will have the email "system@localhost" and the admin user will have
+    the email "admin@localhost".
+    """
+    async with db() as session:
+        role_ids = {
+            name: id_
+            async for name, id_ in await session.stream(
+                select(models.UserRole.name, models.UserRole.id)
+            )
+        }
+        existing_roles = [
+            name
+            async for name in await session.stream_scalars(
+                select(distinct(models.UserRole.name)).join_from(models.User, models.UserRole)
+            )
+        ]
+        if (system_role := UserRole.SYSTEM.value) not in existing_roles and (
+            system_role_id := role_ids.get(system_role)
+        ) is not None:
+            system_user = models.User(
+                user_role_id=system_role_id,
+                username=DEFAULT_SYSTEM_USERNAME,
+                email=DEFAULT_SYSTEM_EMAIL,
+                reset_password=False,
+                password_salt=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+                password_hash=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+            )
+            session.add(system_user)
+        if (admin_role := UserRole.ADMIN.value) not in existing_roles and (
+            admin_role_id := role_ids.get(admin_role)
+        ) is not None:
+            salt = secrets.token_bytes(DEFAULT_SECRET_LENGTH)
+            password = get_env_default_admin_initial_password()
+            compute = partial(compute_password_hash, password=password, salt=salt)
+            loop = asyncio.get_running_loop()
+            hash_ = await loop.run_in_executor(None, compute)
+            admin_user = models.User(
+                user_role_id=admin_role_id,
+                username=DEFAULT_ADMIN_USERNAME,
+                email=DEFAULT_ADMIN_EMAIL,
+                password_salt=salt,
+                password_hash=hash_,
+                reset_password=True,
+            )
+            session.add(admin_user)
+        await session.flush()
+
+
+async def _ensure_admins(
+    db: DbSessionFactory,
+    *,
+    email_sender: Optional[WelcomeEmailSender] = None,
+) -> None:
+    """
+    Ensure that all startup admin users are present in the database. If any are missing, they will
+    be added. Existing records will not be modified.
+    """
+    if not (admins := get_env_admins()):
+        return
+    async with db() as session:
+        existing_emails = set(
+            await session.scalars(
+                select(models.User.email).where(models.User.email.in_(admins.keys()))
+            )
+        )
+        admins = {
+            email: username for email, username in admins.items() if email not in existing_emails
+        }
+        if not admins:
+            return
+        existing_usernames = set(
+            await session.scalars(
+                select(models.User.username).where(models.User.username.in_(admins.values()))
+            )
+        )
+        admins = {
+            email: username
+            for email, username in admins.items()
+            if username not in existing_usernames
+        }
+        if not admins:
+            return
+        admin_role_id = await session.scalar(
+            select(models.UserRole.id).filter_by(name=UserRole.ADMIN.value)
+        )
+        assert admin_role_id is not None, "Admin role not found in database"
+        for email, username in admins.items():
+            values = dict(
+                user_role_id=admin_role_id,
+                username=username,
+                email=email,
+                password_salt=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+                password_hash=secrets.token_bytes(DEFAULT_SECRET_LENGTH),
+                reset_password=True,
+            )
+            await session.execute(insert(models.User).values(values))
+    if email_sender is None:
+        return
+    for exc in await gather(
+        *(email_sender.send_welcome_email(email, username) for email, username in admins.items()),
+        return_exceptions=True,
+    ):
+        if isinstance(exc, Exception):
+            logger.error(f"Failed to send welcome email: {exc}")

{arize_phoenix-8.23.0 → arize_phoenix-8.24.1}/src/phoenix/db/helpers.py

@@ -19,6 +19,7 @@ from sqlalchemy import (
 )
 from typing_extensions import assert_never
 
+from phoenix.config import PLAYGROUND_PROJECT_NAME
 from phoenix.db import models
 
 
@@ -157,3 +158,18 @@ def get_dataset_example_revisions(
             ),
         )
     )
+
+
+_AnyTuple = TypeVar("_AnyTuple", bound=tuple[Any, ...])
+
+
+def exclude_experiment_projects(
+    stmt: Select[_AnyTuple],
+) -> Select[_AnyTuple]:
+    return stmt.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))

{arize_phoenix-8.23.0 → arize_phoenix-8.24.1}/src/phoenix/server/api/context.py

@@ -53,6 +53,7 @@ from phoenix.server.api.dataloaders import (
 )
 from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import DmlEvent
+from phoenix.server.email.types import EmailSender
 from phoenix.server.types import (
     CanGetLastUpdatedAt,
     CanPutItem,
@@ -124,6 +125,7 @@ class Context(BaseContext):
     auth_enabled: bool = False
     secret: Optional[str] = None
     token_store: Optional[TokenStore] = None
+    email_sender: Optional[EmailSender] = None
 
     def get_secret(self) -> str:
         """A type-safe way to get the application secret. Throws an error if the secret is not set.

{arize_phoenix-8.23.0 → arize_phoenix-8.24.1}/src/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

{arize_phoenix-8.23.0 → arize_phoenix-8.24.1}/src/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 = [