arize-phoenix 4.21.0__tar.gz → 4.22.0__tar.gz

{arize_phoenix-4.21.0 → arize_phoenix-4.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.21.0
+Version: 4.22.0
 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-4.21.0 → arize_phoenix-4.22.0}/examples/manually-instrumented-chatbot/chat-service/chat/app.py

@@ -106,15 +106,15 @@ async def messages(messages_payload: MessagesPayload) -> MessagesResponse:
 @app.post("/feedback/")
 async def post_feedback(feedback_request: FeedbackRequest) -> None:
     if feedback_request.feedback == 1:
-        label = "thumbs_up"
+        label = "👍"
     elif feedback_request.feedback == 0:
-        label = "thumbs_down"
+        label = "👎"
 
     request_body = {
         "data": [
             {
                 "span_id": feedback_request.span_id,
-                "name": "correctness",
+                "name": "user_feedback",
                 "annotator_kind": "HUMAN",
                 "result": {"label": label, "score": feedback_request.feedback},
                 "metadata": {},

{arize_phoenix-4.21.0 → arize_phoenix-4.22.0}/pyproject.toml

@@ -288,6 +288,12 @@ clean = [
   "jupyter nbconvert --ClearOutputPreprocessor.enabled=True --ClearMetadataPreprocessor.enabled=True --inplace **/*.ipynb **/internal/*.ipynb **/tracing/*.ipynb **/dolly-pythia-fine-tuned/*.ipynb",
 ]
 
+[tool.hatch.envs.auth.scripts]
+link = "cd src/phoenix/db/migrations/versions && ln -s ../future_versions/cd164e83824f_users_and_tokens.py cd164e83824f_users_and_tokens.py && echo 'created auth migration symlink'"
+unlink = "rm src/phoenix/db/migrations/versions/cd164e83824f_users_and_tokens.py && echo 'removed auth migration symlink'"
+up = "cd src/phoenix/db && alembic upgrade cd164e83824f && echo 'ran auth up-migration'"
+down = "cd src/phoenix/db && alembic downgrade 3be8647b87d8 && echo 'ran auth down-migration'"
+
 [tool.hatch.envs.publish]
 dependencies = [
   "check-wheel-contents",
@@ -300,6 +306,7 @@ testpypi = [
   "twine upload  --verbose --repository testpypi dist/*",
 ]
 pypi = [
+  "if [ -L src/phoenix/db/migrations/versions/cd164e83824f_users_and_tokens.py ]; then echo 'remove auth migration symlink before publishing with `hatch run auth:unlink`'; exit 1; fi",
   "check-wheel-contents dist/",
   "twine upload --verbose dist/*",
 ]

{arize_phoenix-4.21.0 → arize_phoenix-4.22.0}/src/phoenix/config.py

@@ -2,7 +2,7 @@ import os
 import tempfile
 from logging import getLogger
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 
 from .utilities.re import parse_env_headers
 
@@ -60,6 +60,11 @@ ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_GRPC_ENDPOINT = (
     "PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_GRPC_ENDPOINT"
 )
 
+# Auth is under active development. Phoenix users are strongly advised not to
+# set these environment variables until the feature is officially released.
+ENV_DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH = "DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH"
+ENV_DANGEROUSLY_SET_PHOENIX_SECRET = "DANGEROUSLY_SET_PHOENIX_SECRET"
+
 
 def server_instrumentation_is_enabled() -> bool:
     return bool(
@@ -100,6 +105,57 @@ def get_working_dir() -> Path:
     return Path.home().resolve() / ".phoenix"
 
 
+def get_boolean_env_var(env_var: str) -> Optional[bool]:
+    """
+    Parses a boolean environment variable, returning None if the variable is not set.
+    """
+    if (value := os.environ.get(env_var)) is None:
+        return None
+    assert (lower := value.lower()) in (
+        "true",
+        "false",
+    ), f"{env_var} must be set to TRUE or FALSE (case-insensitive)"
+    return lower == "true"
+
+
+def get_env_enable_auth() -> bool:
+    """
+    Gets the value of the DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH environment variable.
+    """
+    return get_boolean_env_var(ENV_DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH) is True
+
+
+def get_env_phoenix_secret() -> Optional[str]:
+    """
+    Gets the value of the DANGEROUSLY_SET_PHOENIX_SECRET environment variable
+    and performs validation.
+    """
+    phoenix_secret = os.environ.get(ENV_DANGEROUSLY_SET_PHOENIX_SECRET)
+    if phoenix_secret is None:
+        return None
+    # todo: add validation for the phoenix secret
+    return phoenix_secret
+
+
+def get_auth_settings() -> Tuple[bool, Optional[str]]:
+    """
+    Gets auth settings and performs validation.
+    """
+    enable_auth = get_env_enable_auth()
+    phoenix_secret = get_env_phoenix_secret()
+    if enable_auth:
+        assert phoenix_secret, (
+            "DANGEROUSLY_SET_PHOENIX_SECRET must be set "
+            "when auth is enabled with DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH"
+        )
+    else:
+        assert not phoenix_secret, (
+            "DANGEROUSLY_SET_PHOENIX_SECRET cannot be set "
+            "unless auth is enabled with DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH"
+        )
+    return enable_auth, phoenix_secret
+
+
 PHOENIX_DIR = Path(__file__).resolve().parent
 # Server config
 SERVER_DIR = PHOENIX_DIR / "server"
@@ -123,6 +179,8 @@ EXPORT_DIR = ROOT_DIR / "exports"
 INFERENCES_DIR = ROOT_DIR / "inferences"
 TRACE_DATASETS_DIR = ROOT_DIR / "trace_datasets"
 
+ENABLE_AUTH, PHOENIX_SECRET = get_auth_settings()
+
 
 def ensure_working_dir() -> None:
     """

arize_phoenix-4.22.0/src/phoenix/db/migrations/future_versions/README.md

@@ -0,0 +1,4 @@
+# Future Migrations
+
+This folder contains future migrations for unreleased features that are under active development. Do not run these migrations unless you are a Phoenix developer.
+

arize_phoenix-4.22.0/src/phoenix/db/migrations/future_versions/cd164e83824f_users_and_tokens.py

@@ -0,0 +1,292 @@
+"""users and tokens
+
+Revision ID: cd164e83824f
+Revises: 10460e46d750
+Create Date: 2024-08-01 18:36:52.157604
+
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Sequence, TypedDict, Union
+
+import sqlalchemy as sa
+from alembic import op
+from phoenix.datetime_utils import normalize_datetime
+from sqlalchemy import (
+    JSON,
+    TIMESTAMP,
+    CheckConstraint,
+    Dialect,
+    ForeignKey,
+    MetaData,
+    TypeDecorator,
+    func,
+    insert,
+)
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.ext.asyncio.engine import AsyncConnection
+from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,
+    mapped_column,
+)
+
+
+class JSONB(JSON):
+    # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    __visit_name__ = "JSONB"
+
+
+@compiles(JSONB, "sqlite")  # type: ignore
+def _(*args: Any, **kwargs: Any) -> str:
+    # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    return "JSONB"
+
+
+JSON_ = (
+    JSON()
+    .with_variant(
+        postgresql.JSONB(),  # type: ignore
+        "postgresql",
+    )
+    .with_variant(
+        JSONB(),
+        "sqlite",
+    )
+)
+
+
+class JsonDict(TypeDecorator[Dict[str, Any]]):
+    # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    cache_ok = True
+    impl = JSON_
+
+    def process_bind_param(self, value: Optional[Dict[str, Any]], _: Dialect) -> Dict[str, Any]:
+        return value if isinstance(value, dict) else {}
+
+
+class JsonList(TypeDecorator[List[Any]]):
+    # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    cache_ok = True
+    impl = JSON_
+
+    def process_bind_param(self, value: Optional[List[Any]], _: Dialect) -> List[Any]:
+        return value if isinstance(value, list) else []
+
+
+class UtcTimeStamp(TypeDecorator[datetime]):
+    # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    cache_ok = True
+    impl = TIMESTAMP(timezone=True)
+
+    def process_bind_param(self, value: Optional[datetime], _: Dialect) -> Optional[datetime]:
+        return normalize_datetime(value)
+
+    def process_result_value(self, value: Optional[Any], _: Dialect) -> Optional[datetime]:
+        return normalize_datetime(value, timezone.utc)
+
+
+class ExperimentRunOutput(TypedDict, total=False):
+    task_output: Any
+
+
+class Base(DeclarativeBase):
+    # Enforce best practices for naming constraints
+    # https://alembic.sqlalchemy.org/en/latest/naming.html#integration-of-naming-conventions-into-operations-autogenerate
+    metadata = MetaData(
+        naming_convention={
+            "ix": "ix_%(table_name)s_%(column_0_N_name)s",
+            "uq": "uq_%(table_name)s_%(column_0_N_name)s",
+            "ck": "ck_%(table_name)s_`%(constraint_name)s`",
+            "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+            "pk": "pk_%(table_name)s",
+        }
+    )
+    type_annotation_map = {
+        Dict[str, Any]: JsonDict,
+        List[Dict[str, Any]]: JsonList,
+        ExperimentRunOutput: JsonDict,
+    }
+
+
+class UserRole(Base):
+    __tablename__ = "user_roles"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    role: Mapped[str] = mapped_column(unique=True)
+
+
+class User(Base):
+    __tablename__ = "users"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_role_id: Mapped[int] = mapped_column(
+        ForeignKey("user_roles.id"),
+        index=True,
+    )
+    username: Mapped[Optional[str]] = mapped_column(nullable=True, unique=True, index=True)
+    email: Mapped[str] = mapped_column(nullable=False, unique=True, index=True)
+    auth_method: Mapped[str] = mapped_column(
+        CheckConstraint("auth_method IN ('LOCAL')", name="valid_auth_method")
+    )
+    password_hash: Mapped[Optional[str]]
+    reset_password: Mapped[bool]
+    created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(
+        UtcTimeStamp, server_default=func.now(), onupdate=func.now()
+    )
+    deleted_at: Mapped[Optional[datetime]] = mapped_column(UtcTimeStamp)
+
+
+# revision identifiers, used by Alembic.
+revision: str = "cd164e83824f"
+down_revision: Union[str, None] = "3be8647b87d8"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+async def insert_roles_and_users(connection: AsyncConnection) -> None:
+    """
+    Populates the `user_roles` table and adds a system user and initial admin
+    user to the `users` table.
+    """
+    await connection.execute(
+        insert(UserRole).values([{"role": "SYSTEM"}, {"role": "ADMIN"}, {"role": "GENERAL"}])
+    )
+    system_user_role_id = sa.select(UserRole.id).where(UserRole.role == "SYSTEM").scalar_subquery()
+    admin_user_role_id = sa.select(UserRole.id).where(UserRole.role == "ADMIN").scalar_subquery()
+    await connection.execute(
+        insert(User).values(
+            [
+                {
+                    "user_role_id": system_user_role_id,
+                    "username": None,
+                    "email": "system@localhost",
+                    "auth_method": "LOCAL",
+                    "password_hash": None,
+                    "reset_password": False,
+                },
+                {
+                    "user_role_id": admin_user_role_id,
+                    "username": "admin",
+                    "email": "admin@localhost",
+                    "auth_method": "LOCAL",
+                    "password_hash": None,  # todo: replace this with the hashed PHOENIX_SECRET
+                    "reset_password": True,
+                },
+            ]
+        )
+    )
+
+
+def upgrade() -> None:
+    op.create_table(
+        "user_roles",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "role",
+            sa.String,
+            nullable=False,
+            unique=True,
+        ),
+    )
+    op.create_table(
+        "users",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "user_role_id",
+            sa.Integer,
+            sa.ForeignKey("user_roles.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column("username", sa.String, nullable=True, unique=True, index=True),
+        sa.Column("email", sa.String, nullable=False, unique=True, index=True),
+        sa.Column(
+            "auth_method",
+            sa.String,
+            sa.CheckConstraint("auth_method IN ('LOCAL')", "valid_auth_method"),
+            nullable=False,
+        ),
+        sa.Column("password_hash", sa.String, nullable=True),
+        sa.Column("reset_password", sa.Boolean, nullable=False),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+            onupdate=sa.func.now(),
+        ),
+        sa.Column(
+            "deleted_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=True,
+        ),
+    )
+    op.create_table(
+        "api_keys",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "user_id",
+            sa.Integer,
+            sa.ForeignKey("users.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column("name", sa.String, nullable=False),
+        sa.Column("description", sa.String, nullable=True),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "expires_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=True,
+        ),
+    )
+    op.create_table(
+        "audit_api_keys",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "api_key_id",
+            sa.Integer,
+            sa.ForeignKey("api_keys.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column(
+            "user_id",
+            sa.Integer,
+            sa.ForeignKey("users.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column(
+            "action",
+            sa.String,
+            sa.CheckConstraint("action IN ('CREATE', 'DELETE')", "valid_action"),
+            nullable=False,
+        ),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+    )
+    op.run_async(insert_roles_and_users)
+
+
+def downgrade() -> None:
+    op.drop_table("audit_api_keys")
+    op.drop_table("api_keys")
+    op.drop_table("users")
+    op.drop_table("user_roles")

arize_phoenix-4.22.0/src/phoenix/db/migrations/versions/.gitignore

@@ -0,0 +1 @@
+cd164e83824f_users_and_tokens.py

{arize_phoenix-4.21.0 → arize_phoenix-4.22.0}/src/phoenix/db/models.py

@@ -34,6 +34,7 @@ from sqlalchemy.orm import (
 )
 from sqlalchemy.sql import expression
 
+from phoenix.config import ENABLE_AUTH
 from phoenix.datetime_utils import normalize_datetime
 
 
@@ -616,3 +617,63 @@ class ExperimentRunAnnotation(Base):
             "name",
         ),
     )
+
+
+# todo: unnest the following models when auth is released (https://github.com/Arize-ai/phoenix/issues/4183)
+if ENABLE_AUTH:
+
+    class UserRole(Base):
+        __tablename__ = "user_roles"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        role: Mapped[str] = mapped_column(unique=True)
+
+    class User(Base):
+        __tablename__ = "users"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        user_role_id: Mapped[int] = mapped_column(
+            ForeignKey("user_roles.id"),
+            index=True,
+        )
+        username: Mapped[Optional[str]] = mapped_column(nullable=True, unique=True, index=True)
+        email: Mapped[str] = mapped_column(nullable=False, unique=True, index=True)
+        auth_method: Mapped[str] = mapped_column(
+            CheckConstraint("auth_method IN ('LOCAL')", name="valid_auth_method")
+        )
+        password_hash: Mapped[Optional[str]]
+        reset_password: Mapped[bool]
+        created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
+        updated_at: Mapped[datetime] = mapped_column(
+            UtcTimeStamp, server_default=func.now(), onupdate=func.now()
+        )
+        deleted_at: Mapped[Optional[datetime]] = mapped_column(UtcTimeStamp)
+
+    class APIKey(Base):
+        __tablename__ = "api_keys"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        user_id: Mapped[int] = mapped_column(
+            ForeignKey("users.id"),
+            index=True,
+        )
+        name: Mapped[str]
+        description: Mapped[Optional[str]]
+        created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
+        expires_at: Mapped[Optional[datetime]] = mapped_column(UtcTimeStamp)
+
+    # todo: standardize audit table format (https://github.com/Arize-ai/phoenix/issues/4185)
+    class AuditAPIKey(Base):
+        __tablename__ = "audit_api_keys"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        api_key_id: Mapped[int] = mapped_column(
+            ForeignKey("api_keys.id"),
+            nullable=False,
+            index=True,
+        )
+        user_id: Mapped[int] = mapped_column(
+            ForeignKey("users.id"),
+            nullable=False,
+            index=True,
+        )
+        action: Mapped[str] = mapped_column(
+            CheckConstraint("action IN ('CREATE', 'DELETE')", name="valid_action")
+        )
+        created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())

{arize_phoenix-4.21.0 → arize_phoenix-4.22.0}/src/phoenix/server/static/.vite/manifest.json

@@ -1,21 +1,21 @@
 {
-  "_components-D2V-mOGq.js": {
-    "file": "assets/components-D2V-mOGq.js",
+  "_components-Bhx3QVW0.js": {
+    "file": "assets/components-Bhx3QVW0.js",
     "name": "components",
     "imports": [
       "_vendor-BMWfu6zp.js",
       "_vendor-arizeai-Sj74jm5V.js",
-      "_pages-CChOjmat.js",
+      "_pages-DG-5zgoV.js",
       "_vendor-three-DwGkEfCM.js",
       "_vendor-codemirror-DO3VqEcD.js"
     ]
   },
-  "_pages-CChOjmat.js": {
-    "file": "assets/pages-CChOjmat.js",
+  "_pages-DG-5zgoV.js": {
+    "file": "assets/pages-DG-5zgoV.js",
     "name": "pages",
     "imports": [
       "_vendor-BMWfu6zp.js",
-      "_components-D2V-mOGq.js",
+      "_components-Bhx3QVW0.js",
       "_vendor-arizeai-Sj74jm5V.js",
       "_vendor-recharts-BGN0SxgJ.js",
       "_vendor-codemirror-DO3VqEcD.js"
@@ -61,15 +61,15 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-B52Z3aZG.js",
+    "file": "assets/index-CZg-95kd.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
       "_vendor-BMWfu6zp.js",
       "_vendor-arizeai-Sj74jm5V.js",
-      "_components-D2V-mOGq.js",
-      "_pages-CChOjmat.js",
+      "_components-Bhx3QVW0.js",
+      "_pages-DG-5zgoV.js",
       "_vendor-three-DwGkEfCM.js",
       "_vendor-codemirror-DO3VqEcD.js",
       "_vendor-recharts-BGN0SxgJ.js"