arize-phoenix 10.0.4__py3-none-any.whl → 12.28.1__py3-none-any.whl

phoenix/db/pg_config.py

@@ -10,12 +10,14 @@ from typing_extensions import assert_never
 def get_pg_config(
     url: URL,
     driver: Literal["psycopg", "asyncpg"],
+    enforce_ssl: bool = False,
 ) -> tuple[URL, dict[str, Any]]:
     """Convert SQLAlchemy URL to driver-specific configuration.
 
     Args:
         url: SQLAlchemy URL
         driver: "psycopg" or "asyncpg"
+        enforce_ssl: If True, ensure SSL is enabled (required for AWS RDS IAM auth)
 
     Returns:
         Tuple of (base_url, connect_args):
@@ -26,6 +28,14 @@ def get_pg_config(
     query = url.query
     ssl_args = _get_ssl_args(query)
 
+    if enforce_ssl and not ssl_args:
+        ssl_args = {"sslmode": "require"}
+    elif enforce_ssl and ssl_args.get("sslmode") == "disable":
+        raise ValueError(
+            "SSL cannot be disabled when using AWS RDS IAM authentication. "
+            "Remove 'sslmode=disable' from the connection string."
+        )
+
     # Create base URL without SSL parameters
     base_url = url.set(
         drivername=f"postgresql+{driver}",

phoenix/db/types/model_provider.py

@@ -6,3 +6,7 @@ class ModelProvider(Enum):
     AZURE_OPENAI = "AZURE_OPENAI"
     ANTHROPIC = "ANTHROPIC"
     GOOGLE = "GOOGLE"
+    DEEPSEEK = "DEEPSEEK"
+    XAI = "XAI"
+    OLLAMA = "OLLAMA"
+    AWS = "AWS"

phoenix/db/types/token_price_customization.py

@@ -0,0 +1,29 @@
+from abc import ABC
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ValidationError
+
+
+class TokenPriceCustomization(BaseModel, ABC):
+    model_config = {"extra": "allow"}
+
+
+class ThresholdBasedTokenPriceCustomization(TokenPriceCustomization):
+    type: Literal["threshold_based"] = "threshold_based"
+    key: str
+    threshold: float
+    new_rate: float
+
+
+class TokenPriceCustomizationParser:
+    """Intended to be forward-compatible while maintaining the ability to round-trip."""
+
+    @staticmethod
+    def parse(data: Optional[dict[str, Any]]) -> Optional[TokenPriceCustomization]:
+        if not data:
+            return None
+        try:
+            return ThresholdBasedTokenPriceCustomization.model_validate(data)
+        except ValidationError:
+            pass
+        return TokenPriceCustomization.model_validate(data)

phoenix/db/types/trace_retention.py

@@ -5,7 +5,9 @@ from typing import Annotated, Iterable, Literal, Optional, Union
 
 import sqlalchemy as sa
 from pydantic import AfterValidator, BaseModel, Field, RootModel
+from sqlalchemy import func
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql.roles import InElementRole
 
 from phoenix.utilities import hour_of_week
 
@@ -25,19 +27,25 @@ class _MaxDays(BaseModel):
 class _MaxCount(BaseModel):
     max_count: Annotated[int, Field(ge=0)]
 
-    @property
-    def max_count_filter(self) -> sa.ColumnElement[bool]:
+    def max_count_filter(
+        self,
+        project_rowids: Union[Iterable[int], InElementRole],
+    ) -> sa.ColumnElement[bool]:
         if self.max_count <= 0:
             return sa.literal(False)
         from phoenix.db.models import Trace
 
-        return Trace.start_time < (
-            sa.select(Trace.start_time)
-            .order_by(Trace.start_time.desc())
-            .offset(self.max_count - 1)
-            .limit(1)
-            .scalar_subquery()
+        ranked = (
+            sa.select(
+                Trace.id,
+                func.row_number()
+                .over(partition_by=Trace.project_rowid, order_by=Trace.start_time.desc())
+                .label("rn"),
+            )
+            .where(Trace.project_rowid.in_(project_rowids))
+            .cte("ranked")
         )
+        return Trace.id.in_(sa.select(ranked.c.id).where(ranked.c.rn > self.max_count))
 
 
 class MaxDaysRule(_MaxDays, BaseModel):
@@ -49,7 +57,7 @@ class MaxDaysRule(_MaxDays, BaseModel):
     async def delete_traces(
         self,
         session: AsyncSession,
-        project_rowids: Union[Iterable[int], sa.ScalarSelect[int]],
+        project_rowids: Union[Iterable[int], InElementRole],
     ) -> set[int]:
         if self.max_days <= 0:
             return set()
@@ -73,7 +81,7 @@ class MaxCountRule(_MaxCount, BaseModel):
     async def delete_traces(
         self,
         session: AsyncSession,
-        project_rowids: Union[Iterable[int], sa.ScalarSelect[int]],
+        project_rowids: Union[Iterable[int], InElementRole],
     ) -> set[int]:
         if self.max_count <= 0:
             return set()
@@ -82,7 +90,7 @@ class MaxCountRule(_MaxCount, BaseModel):
         stmt = (
             sa.delete(Trace)
             .where(Trace.project_rowid.in_(project_rowids))
-            .where(self.max_count_filter)
+            .where(self.max_count_filter(project_rowids))
             .returning(Trace.project_rowid)
         )
         return set(await session.scalars(stmt))
@@ -97,7 +105,7 @@ class MaxDaysOrCountRule(_MaxDays, _MaxCount, BaseModel):
     async def delete_traces(
         self,
         session: AsyncSession,
-        project_rowids: Union[Iterable[int], sa.ScalarSelect[int]],
+        project_rowids: Union[Iterable[int], InElementRole],
     ) -> set[int]:
         if self.max_days <= 0 and self.max_count <= 0:
             return set()
@@ -106,7 +114,7 @@ class MaxDaysOrCountRule(_MaxDays, _MaxCount, BaseModel):
         stmt = (
             sa.delete(Trace)
             .where(Trace.project_rowid.in_(project_rowids))
-            .where(sa.or_(self.max_days_filter, self.max_count_filter))
+            .where(sa.or_(self.max_days_filter, self.max_count_filter(project_rowids)))
             .returning(Trace.project_rowid)
         )
         return set(await session.scalars(stmt))
@@ -123,7 +131,7 @@ class TraceRetentionRule(RootModel[Union[MaxDaysRule, MaxCountRule, MaxDaysOrCou
     async def delete_traces(
         self,
         session: AsyncSession,
-        project_rowids: Union[Iterable[int], sa.ScalarSelect[int]],
+        project_rowids: Union[Iterable[int], InElementRole],
     ) -> set[int]:
         return await self.root.delete_traces(session, project_rowids)
 
@@ -192,7 +200,7 @@ class TraceRetentionCronExpression(RootModel[str]):
 
 def _parse_field(field: str, min_val: int, max_val: int) -> set[int]:
     """
-    Parse a cron field and return the set of matching values.
+    Parses a cron field and returns the set of matching values.
 
     Args:
         field (str): The cron field to parse

phoenix/experiments/evaluators/utils.py

@@ -19,9 +19,9 @@ def unwrap_json(obj: JSONSerializable) -> JSONSerializable:
         if len(obj) == 1:
             key = next(iter(obj.keys()))
             output = obj[key]
-            assert isinstance(
-                output, (dict, list, str, int, float, bool, type(None))
-            ), "Output must be JSON serializable"
+            assert isinstance(output, (dict, list, str, int, float, bool, type(None))), (
+                "Output must be JSON serializable"
+            )
             return output
     return obj
 

phoenix/experiments/functions.py

@@ -10,7 +10,7 @@ from copy import deepcopy
 from dataclasses import replace
 from datetime import datetime, timezone
 from itertools import product
-from typing import Any, Literal, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union, cast
 from urllib.parse import urljoin
 
 import httpx
@@ -65,6 +65,41 @@ from phoenix.trace.attributes import flatten
 from phoenix.utilities.client import VersionedAsyncClient, VersionedClient
 from phoenix.utilities.json import jsonify
 
+if TYPE_CHECKING:
+    from phoenix.client.resources.datasets import Dataset as ClientDataset
+
+
+def _convert_client_dataset(new_dataset: "ClientDataset") -> Dataset:
+    """
+    Converts Dataset objects from `phoenix.client` to Dataset objects compatible with experiments.
+    """
+    examples_dict: dict[str, Example] = {}
+    for example_data in new_dataset.examples:
+        legacy_example = Example(
+            id=example_data["id"],
+            input=example_data["input"],
+            output=example_data["output"],
+            metadata=example_data["metadata"],
+            updated_at=datetime.fromisoformat(example_data["updated_at"]),
+        )
+        examples_dict[legacy_example.id] = legacy_example
+
+    return Dataset(
+        id=new_dataset.id,
+        version_id=new_dataset.version_id,
+        examples=examples_dict,
+    )
+
+
+def _is_new_client_dataset(dataset: Any) -> bool:
+    """Check if dataset is from new client (has list examples)."""
+    try:
+        from phoenix.client.resources.datasets import Dataset as _ClientDataset
+
+        return isinstance(dataset, _ClientDataset)
+    except ImportError:
+        return False
+
 
 def _phoenix_clients() -> tuple[httpx.Client, httpx.AsyncClient]:
     return VersionedClient(
@@ -74,6 +109,64 @@ def _phoenix_clients() -> tuple[httpx.Client, httpx.AsyncClient]:
     )
 
 
+def _get_all_experiment_runs(
+    client: httpx.Client,
+    experiment_id: str,
+    page_size: int = 50,
+) -> list[ExperimentRun]:
+    """
+    Fetch all experiment runs using pagination to handle large datasets.
+
+    Args:
+        client: The HTTP client to use for requests.
+        experiment_id: The ID of the experiment.
+        page_size: Number of runs to fetch per page. Defaults to 50.
+
+    Returns:
+        List of all experiment runs as ExperimentRun objects.
+    """
+    all_runs: list[dict[str, Any]] = []
+    cursor = None
+
+    while True:
+        params: dict[str, Any] = {"limit": page_size}
+        if cursor:
+            params["cursor"] = cursor
+
+        try:
+            response = client.get(
+                f"v1/experiments/{experiment_id}/runs",
+                params=params,
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            runs = data["data"]
+            all_runs.extend(runs)
+
+            # Check if there are more pages
+            cursor = data.get("next_cursor")
+            if not cursor:
+                break
+
+        except HTTPStatusError as e:
+            if e.response.status_code == 404:
+                # Experiment doesn't exist - treat as empty result
+                break
+            else:
+                raise
+
+    # Convert dicts to ExperimentRun objects
+    experiment_runs: list[ExperimentRun] = []
+    for run in all_runs:
+        # Parse datetime strings
+        run["start_time"] = datetime.fromisoformat(run["start_time"])
+        run["end_time"] = datetime.fromisoformat(run["end_time"])
+        experiment_runs.append(ExperimentRun.from_dict(run))
+
+    return experiment_runs
+
+
 Evaluators: TypeAlias = Union[
     ExperimentEvaluator,
     Sequence[ExperimentEvaluator],
@@ -85,7 +178,7 @@ RateLimitErrors: TypeAlias = Union[type[BaseException], Sequence[type[BaseExcept
 
 
 def run_experiment(
-    dataset: Dataset,
+    dataset: Union[Dataset, Any],  # Accept both legacy and new client datasets
     task: ExperimentTask,
     evaluators: Optional[Evaluators] = None,
     *,
@@ -166,11 +259,20 @@ def run_experiment(
         RanExperiment: The results of the experiment and evaluation. Additional evaluations can be
             added to the experiment using the `evaluate_experiment` function.
     """
+    # Auto-convert client Dataset objects to legacy format
+    normalized_dataset: Dataset
+    if _is_new_client_dataset(dataset):
+        normalized_dataset = _convert_client_dataset(cast("ClientDataset", dataset))
+    else:
+        normalized_dataset = dataset
+
     task_signature = inspect.signature(task)
     _validate_task_signature(task_signature)
 
-    if not dataset.examples:
-        raise ValueError(f"Dataset has no examples: {dataset.id=}, {dataset.version_id=}")
+    if not normalized_dataset.examples:
+        raise ValueError(
+            f"Dataset has no examples: {normalized_dataset.id=}, {normalized_dataset.version_id=}"
+        )
     # Add this to the params once supported in the UI
     repetitions = 1
     assert repetitions > 0, "Must run the experiment at least once."
@@ -179,7 +281,7 @@ def run_experiment(
     sync_client, async_client = _phoenix_clients()
 
     payload = {
-        "version_id": dataset.version_id,
+        "version_id": normalized_dataset.version_id,
         "name": experiment_name,
         "description": experiment_description,
         "metadata": experiment_metadata,
@@ -187,23 +289,23 @@ def run_experiment(
     }
     if not dry_run:
         experiment_response = sync_client.post(
-            f"/v1/datasets/{dataset.id}/experiments",
+            f"v1/datasets/{normalized_dataset.id}/experiments",
             json=payload,
         )
         experiment_response.raise_for_status()
         exp_json = experiment_response.json()["data"]
         project_name = exp_json["project_name"]
         experiment = Experiment(
-            dataset_id=dataset.id,
-            dataset_version_id=dataset.version_id,
+            dataset_id=normalized_dataset.id,
+            dataset_version_id=normalized_dataset.version_id,
             repetitions=repetitions,
             id=exp_json["id"],
             project_name=project_name,
         )
     else:
         experiment = Experiment(
-            dataset_id=dataset.id,
-            dataset_version_id=dataset.version_id,
+            dataset_id=normalized_dataset.id,
+            dataset_version_id=normalized_dataset.version_id,
             repetitions=repetitions,
             id=DRY_RUN,
             project_name="",
@@ -216,18 +318,18 @@ def run_experiment(
     print("🧪 Experiment started.")
     if dry_run:
         examples = {
-            (ex := dataset[i]).id: ex
-            for i in pd.Series(range(len(dataset)))
-            .sample(min(len(dataset), int(dry_run)), random_state=42)
+            (ex := normalized_dataset[i]).id: ex
+            for i in pd.Series(range(len(normalized_dataset)))
+            .sample(min(len(normalized_dataset), int(dry_run)), random_state=42)
             .sort_values()
         }
         id_selection = "\n".join(examples)
         print(f"🌵️ This is a dry-run for these example IDs:\n{id_selection}")
-        dataset = replace(dataset, examples=examples)
+        normalized_dataset = replace(normalized_dataset, examples=examples)
     else:
-        dataset_experiments_url = get_dataset_experiments_url(dataset_id=dataset.id)
+        dataset_experiments_url = get_dataset_experiments_url(dataset_id=normalized_dataset.id)
         experiment_compare_url = get_experiment_url(
-            dataset_id=dataset.id,
+            dataset_id=normalized_dataset.id,
             experiment_id=experiment.id,
         )
         print(f"📺 View dataset experiments: {dataset_experiments_url}")
@@ -259,7 +361,7 @@ def run_experiment(
                 try:
                     # Try to create the run directly
                     resp = sync_client.post(
-                        f"/v1/experiments/{experiment.id}/runs", json=jsonify(exp_run)
+                        f"v1/experiments/{experiment.id}/runs", json=jsonify(exp_run)
                     )
                     resp.raise_for_status()
                     exp_run = replace(exp_run, id=resp.json()["data"]["id"])
@@ -274,8 +376,11 @@ def run_experiment(
         error: Optional[BaseException] = None
         status = Status(StatusCode.OK)
         with ExitStack() as stack:
-            span: Span = stack.enter_context(
-                tracer.start_as_current_span(root_span_name, context=Context())
+            span = cast(
+                Span,
+                stack.enter_context(
+                    tracer.start_as_current_span(root_span_name, context=Context())
+                ),
             )
             stack.enter_context(capture_spans(resource))
             try:
@@ -316,9 +421,9 @@ def run_experiment(
             span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND, root_span_kind)
             span.set_status(status)
 
-        assert isinstance(
-            output, (dict, list, str, int, float, bool, type(None))
-        ), "Output must be JSON serializable"
+        assert isinstance(output, (dict, list, str, int, float, bool, type(None))), (
+            "Output must be JSON serializable"
+        )
 
         exp_run = ExperimentRun(
             start_time=_decode_unix_nano(cast(int, span.start_time)),
@@ -334,7 +439,7 @@ def run_experiment(
             try:
                 # Try to create the run directly
                 resp = sync_client.post(
-                    f"/v1/experiments/{experiment.id}/runs", json=jsonify(exp_run)
+                    f"v1/experiments/{experiment.id}/runs", json=jsonify(exp_run)
                 )
                 resp.raise_for_status()
                 exp_run = replace(exp_run, id=resp.json()["data"]["id"])
@@ -373,7 +478,7 @@ def run_experiment(
                         None,
                         functools.partial(
                             sync_client.post,
-                            url=f"/v1/experiments/{experiment.id}/runs",
+                            url=f"v1/experiments/{experiment.id}/runs",
                             json=jsonify(exp_run),
                         ),
                     )
@@ -391,8 +496,11 @@ def run_experiment(
         error: Optional[BaseException] = None
         status = Status(StatusCode.OK)
         with ExitStack() as stack:
-            span: Span = stack.enter_context(
-                tracer.start_as_current_span(root_span_name, context=Context())
+            span = cast(
+                Span,
+                stack.enter_context(
+                    tracer.start_as_current_span(root_span_name, context=Context())
+                ),
             )
             stack.enter_context(capture_spans(resource))
             try:
@@ -427,9 +535,9 @@ def run_experiment(
             span.set_attribute(OPENINFERENCE_SPAN_KIND, root_span_kind)
             span.set_status(status)
 
-        assert isinstance(
-            output, (dict, list, str, int, float, bool, type(None))
-        ), "Output must be JSON serializable"
+        assert isinstance(output, (dict, list, str, int, float, bool, type(None))), (
+            "Output must be JSON serializable"
+        )
 
         exp_run = ExperimentRun(
             start_time=_decode_unix_nano(cast(int, span.start_time)),
@@ -448,7 +556,7 @@ def run_experiment(
                     None,
                     functools.partial(
                         sync_client.post,
-                        url=f"/v1/experiments/{experiment.id}/runs",
+                        url=f"v1/experiments/{experiment.id}/runs",
                         json=jsonify(exp_run),
                     ),
                 )
@@ -491,23 +599,17 @@ def run_experiment(
 
     test_cases = [
         TestCase(example=deepcopy(ex), repetition_number=rep)
-        for ex, rep in product(dataset.examples.values(), range(1, repetitions + 1))
+        for ex, rep in product(normalized_dataset.examples.values(), range(1, repetitions + 1))
     ]
     task_runs, _execution_details = executor.run(test_cases)
     print("✅ Task runs completed.")
 
     # Get the final state of runs from the database
     if not dry_run:
-        all_runs = sync_client.get(f"/v1/experiments/{experiment.id}/runs").json()["data"]
-        task_runs = []
-        for run in all_runs:
-            # Parse datetime strings
-            run["start_time"] = datetime.fromisoformat(run["start_time"])
-            run["end_time"] = datetime.fromisoformat(run["end_time"])
-            task_runs.append(ExperimentRun.from_dict(run))
+        task_runs = _get_all_experiment_runs(sync_client, experiment.id)
 
         # Check if we got all expected runs
-        expected_runs = len(dataset.examples) * repetitions
+        expected_runs = len(normalized_dataset.examples) * repetitions
         actual_runs = len(task_runs)
         if actual_runs < expected_runs:
             print(
@@ -515,12 +617,14 @@ def run_experiment(
                 "completed successfully."
             )
 
-    params = ExperimentParameters(n_examples=len(dataset.examples), n_repetitions=repetitions)
+    params = ExperimentParameters(
+        n_examples=len(normalized_dataset.examples), n_repetitions=repetitions
+    )
     task_summary = TaskSummary.from_task_runs(params, task_runs)
     ran_experiment: RanExperiment = object.__new__(RanExperiment)
     ran_experiment.__init__(  # type: ignore[misc]
         params=params,
-        dataset=dataset,
+        dataset=normalized_dataset,
         runs={r.id: r for r in task_runs if r is not None},
         task_summary=task_summary,
         **_asdict(experiment),
@@ -561,16 +665,14 @@ def evaluate_experiment(
     else:
         dataset = Dataset.from_dict(
             sync_client.get(
-                f"/v1/datasets/{dataset_id}/examples",
+                f"v1/datasets/{dataset_id}/examples",
                 params={"version_id": str(dataset_version_id)},
             ).json()["data"]
         )
         if not dataset.examples:
             raise ValueError(f"Dataset has no examples: {dataset_id=}, {dataset_version_id=}")
-        experiment_runs = {
-            exp_run["id"]: ExperimentRun.from_dict(exp_run)
-            for exp_run in sync_client.get(f"/v1/experiments/{experiment.id}/runs").json()["data"]
-        }
+        all_runs = _get_all_experiment_runs(sync_client, experiment.id)
+        experiment_runs = {exp_run.id: exp_run for exp_run in all_runs}
         if not experiment_runs:
             raise ValueError("Experiment has not been run")
         params = ExperimentParameters(n_examples=len(dataset.examples))
@@ -622,8 +724,11 @@ def evaluate_experiment(
         status = Status(StatusCode.OK)
         root_span_name = f"Evaluation: {evaluator.name}"
         with ExitStack() as stack:
-            span: Span = stack.enter_context(
-                tracer.start_as_current_span(root_span_name, context=Context())
+            span = cast(
+                Span,
+                stack.enter_context(
+                    tracer.start_as_current_span(root_span_name, context=Context())
+                ),
             )
             stack.enter_context(capture_spans(resource))
             try:
@@ -660,7 +765,7 @@ def evaluate_experiment(
             trace_id=_str_trace_id(span.get_span_context().trace_id),  # type: ignore[no-untyped-call]
         )
         if not dry_run:
-            resp = sync_client.post("/v1/experiment_evaluations", json=jsonify(eval_run))
+            resp = sync_client.post("v1/experiment_evaluations", json=jsonify(eval_run))
             resp.raise_for_status()
             eval_run = replace(eval_run, id=resp.json()["data"]["id"])
         return eval_run
@@ -674,8 +779,11 @@ def evaluate_experiment(
         status = Status(StatusCode.OK)
         root_span_name = f"Evaluation: {evaluator.name}"
         with ExitStack() as stack:
-            span: Span = stack.enter_context(
-                tracer.start_as_current_span(root_span_name, context=Context())
+            span = cast(
+                Span,
+                stack.enter_context(
+                    tracer.start_as_current_span(root_span_name, context=Context())
+                ),
             )
             stack.enter_context(capture_spans(resource))
             try:
@@ -719,7 +827,7 @@ def evaluate_experiment(
                 None,
                 functools.partial(
                     sync_client.post,
-                    url="/v1/experiment_evaluations",
+                    url="v1/experiment_evaluations",
                     json=jsonify(eval_run),
                 ),
             )

phoenix/experiments/tracing.py

@@ -8,7 +8,7 @@ from typing import Any, Optional
 
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.trace import INVALID_TRACE_ID
+from opentelemetry.trace import INVALID_SPAN_ID
 from wrapt import apply_patch, resolve_path, wrap_function_wrapper
 
 
@@ -29,7 +29,7 @@ class SpanModifier:
         Args:
           span: ReadableSpan: the span to modify
         """
-        if (ctx := span._context) is None or ctx.span_id == INVALID_TRACE_ID:
+        if (ctx := span._context) is None or ctx.span_id == INVALID_SPAN_ID:
             return
         span._resource = span._resource.merge(self._resource)
 

phoenix/experiments/types.py

@@ -322,7 +322,7 @@ class _HasStats:
             text = self.stats.__str__()
         else:
             text = self.stats.to_markdown(index=False)
-        return f"{self.title}\n{'-'*len(self.title)}\n" + text
+        return f"{self.title}\n{'-' * len(self.title)}\n" + text
 
 
 @dataclass(frozen=True)

phoenix/inferences/inferences.py

@@ -13,11 +13,10 @@ from pandas import DataFrame, Series, Timestamp, read_parquet
 from pandas.api.types import (
     is_numeric_dtype,
 )
-from typing_extensions import TypeAlias
+from typing_extensions import TypeAlias, deprecated
 
 from phoenix.config import GENERATED_INFERENCES_NAME_PREFIX, INFERENCES_DIR
 from phoenix.datetime_utils import normalize_timestamps
-from phoenix.utilities.deprecation import deprecated
 
 from . import errors as err
 from .schema import (