redis-featureform 3.0.0__py3-none-any.whl

featureform/__init__.py

@@ -0,0 +1,335 @@
+"""Featureform Python client library.
+
+Enterprise-grade Python client for Featureform v2 API.
+"""
+
+from featureform._apply_context import get_active_apply_client, get_active_apply_workspace_id
+from featureform._apply_wait import ApplyWaitError, WaitTarget
+from featureform._internal.logging import (
+    LogLevel,
+    configure_logging,
+    current_request_id,
+    get_logger,
+    request_id_context,
+    temporary_log_level,
+)
+from featureform._internal.telemetry import TelemetryConfig
+from featureform._version import resolve_version
+from featureform.client import (
+    ApplyResult,
+    ApplyWaitResult,
+    Client,
+    GraphClientBase,
+    GRPCGraphClient,
+    PingResult,
+    PlannedJob,
+    PlannedTask,
+    ProviderClient,
+    ResourceChange,
+    RESTGraphClient,
+    SecretProviderClient,
+    WorkspaceClient,
+)
+from featureform.config import Config
+from featureform.errors import (
+    AlreadyExistsError,
+    ConnectionError,
+    DataframeFallbackError,
+    DataframePlanResolutionError,
+    FeatureformError,
+    FlightFallbackUnavailableError,
+    InternalError,
+    InvalidArgumentError,
+    NotFoundError,
+    ProviderWorkspaceMismatchError,
+    SparkExecutionError,
+    TimeoutError,
+    ValidationError,
+)
+
+# New DSL resource classes
+from featureform.resources import (
+    AggregateFeature,
+    AttributeFeature,
+    Dataset,
+    EnvSecretProvider,
+    Feature,
+    FeatureBuilder,
+    FeatureInput,
+    FeatureResource,
+    FeatureView,
+    FunctionNormalizerDetails,
+    IcebergPrimaryDataset,
+    IcebergProvider,
+    K8sSecretProvider,
+    Label,
+    LabelBuilder,
+    LabelResource,
+    PostgresPrimaryDataset,
+    PostgresProvider,
+    PostgresTransformedDataset,
+    PrimaryDataset,
+    RealtimeFeature,
+    RealtimeInput,
+    RedisClusterProvider,
+    RedisProvider,
+    Resource,
+    ResourceRegistry,
+    S3Provider,
+    SecretProviderBase,
+    SerializerDetails,
+    SnowflakePrimaryDataset,
+    SnowflakeProvider,
+    SnowflakeTransformedDataset,
+    SparkProvider,
+    SparkTransformedDataset,
+    TrainingSet,
+    TransformedDataset,
+    VaultSecretProvider,
+    postgres_sql_transformation,
+    realtime_feature,
+    spark_sql_transformation,
+)
+from featureform.resources import Provider as ProviderBase
+from featureform.resources.entity import Entity
+from featureform.spark import DataframeExecutionInfo, SparkOptions, get_execution_info
+from featureform.types import (
+    CLEAR,
+    AWSSecretRef,
+    AWSSecretsManagerSecretConfig,
+    AzureSecretRef,
+    CreateWorkspaceRequest,
+    DynamoDBConfig,
+    EnvSecretConfig,
+    EnvSecretRef,
+    GCPSecretRef,
+    K8sSecretRef,
+    KafkaConfig,
+    KubernetesSecretConfig,
+    PostgresConfig,
+    Provider,
+    ProviderConfig,
+    ProviderType,
+    RedisConfig,
+    RegisterProviderRequest,
+    RegisterSecretProviderRequest,
+    S3Config,
+    SecretProvider,
+    SecretProviderConfig,
+    SecretProviderType,
+    SecretRef,
+    SnowflakeConfig,
+    SparkKerberosConfig,
+    SparkProviderConfig,
+    UpdateProviderRequest,
+    UpdateSecretProviderRequest,
+    UpdateWorkspaceRequest,
+    VaultSecretConfig,
+    VaultSecretRef,
+    Workspace,
+)
+
+# Type helpers from types.resource
+from featureform.types.resource import (
+    AggregateFunction,
+    FeatureLag,
+    IcebergConfig,
+    IcebergTableLocation,
+    MaterializationEngine,
+    PostgresDatasetConfig,
+    ScalarType,
+    SparkEnv,
+    SparkExecutionDefaults,
+    SparkJobConfig,
+    TableLocation,
+    TrainingSetType,
+    ValueType,
+)
+
+__version__ = resolve_version()
+
+
+def get_postgres(name: str) -> PostgresProvider:
+    """Resolve a registered Postgres provider within an active apply context.
+
+    Use this in resource files loaded by ``ff apply`` when you want method-style
+    authoring such as ``postgres.dataset(...)`` or ``@postgres.sql_transformation(...)``.
+    Outside apply, use ``client.get_postgres(...)`` instead.
+    """
+
+    client = get_active_apply_client()
+    workspace_id = get_active_apply_workspace_id()
+    if client is None:
+        raise InvalidArgumentError(
+            "ff.get_postgres() requires an active apply context. Use client.get_postgres() "
+            "outside resource-file apply flows."
+        )
+    return client.get_postgres(name, workspace=workspace_id)
+
+
+def get_provider(name: str) -> ProviderBase:
+    """Resolve a registered provider within an active apply context.
+
+    Outside apply, use ``client.get_provider(...)`` instead.
+    """
+
+    client = get_active_apply_client()
+    workspace_id = get_active_apply_workspace_id()
+    if client is None:
+        raise InvalidArgumentError(
+            "ff.get_provider() requires an active apply context. Use client.get_provider() "
+            "outside resource-file apply flows."
+        )
+    return client.get_provider(name, workspace=workspace_id)
+
+
+__all__ = [
+    # Version
+    "__version__",
+    # Client
+    "ApplyResult",
+    "ApplyWaitError",
+    "ApplyWaitResult",
+    "Client",
+    "GRPCGraphClient",
+    "GraphClientBase",
+    "PingResult",
+    "PlannedJob",
+    "PlannedTask",
+    "ProviderClient",
+    "RESTGraphClient",
+    "ResourceChange",
+    "SecretProviderClient",
+    "WaitTarget",
+    "WorkspaceClient",
+    # Config
+    "Config",
+    "CLEAR",
+    # Logging
+    "LogLevel",
+    "configure_logging",
+    "current_request_id",
+    "get_logger",
+    "request_id_context",
+    "temporary_log_level",
+    # Telemetry
+    "TelemetryConfig",
+    # Errors
+    "AlreadyExistsError",
+    "ConnectionError",
+    "DataframeFallbackError",
+    "DataframePlanResolutionError",
+    "FeatureformError",
+    "FlightFallbackUnavailableError",
+    "get_postgres",
+    "get_provider",
+    "InternalError",
+    "InvalidArgumentError",
+    "NotFoundError",
+    "ProviderWorkspaceMismatchError",
+    "SparkExecutionError",
+    "TimeoutError",
+    "ValidationError",
+    # New DSL - Base
+    "Resource",
+    "ResourceRegistry",
+    # New DSL - Secrets
+    "SecretProviderBase",
+    "EnvSecretProvider",
+    "VaultSecretProvider",
+    "K8sSecretProvider",
+    "EnvSecretRef",
+    "AWSSecretRef",
+    "GCPSecretRef",
+    "AzureSecretRef",
+    "VaultSecretRef",
+    "K8sSecretRef",
+    "SecretRef",
+    # New DSL - Providers (NOT Resources - registered separately)
+    "IcebergProvider",
+    "PostgresProvider",
+    "SnowflakeProvider",
+    "ProviderBase",
+    "RedisProvider",
+    "RedisClusterProvider",
+    "S3Provider",
+    "SparkProvider",
+    "SparkOptions",
+    "get_execution_info",
+    "postgres_sql_transformation",
+    "spark_sql_transformation",
+    # New DSL - Entity
+    "Entity",
+    # New DSL - Datasets
+    "Dataset",
+    "IcebergPrimaryDataset",
+    "PostgresPrimaryDataset",
+    "PostgresTransformedDataset",
+    "PrimaryDataset",
+    "SnowflakePrimaryDataset",
+    "SnowflakeTransformedDataset",
+    "SparkTransformedDataset",
+    "TransformedDataset",
+    # New DSL - Features (builder pattern)
+    "Feature",
+    "FeatureBuilder",
+    "FeatureResource",
+    "FeatureInput",
+    "AttributeFeature",
+    "AggregateFeature",
+    "FunctionNormalizerDetails",
+    # New DSL - Labels (builder pattern)
+    "Label",
+    "LabelBuilder",
+    "LabelResource",
+    "RealtimeFeature",
+    "RealtimeInput",
+    "SerializerDetails",
+    "realtime_feature",
+    # New DSL - Training
+    "FeatureView",
+    "TrainingSet",
+    # Type helpers
+    "AggregateFunction",
+    "FeatureLag",
+    "IcebergConfig",
+    "IcebergTableLocation",
+    "MaterializationEngine",
+    "PostgresDatasetConfig",
+    "ScalarType",
+    "SparkEnv",
+    "SparkExecutionDefaults",
+    "SparkJobConfig",
+    "DataframeExecutionInfo",
+    "TableLocation",
+    "TrainingSetType",
+    "ValueType",
+    # Workspace Types
+    "CreateWorkspaceRequest",
+    "UpdateWorkspaceRequest",
+    "Workspace",
+    # Provider Types (legacy)
+    "KafkaConfig",
+    "PostgresConfig",
+    "Provider",
+    "ProviderConfig",
+    "ProviderType",
+    "DynamoDBConfig",
+    "RedisConfig",
+    "RegisterProviderRequest",
+    "S3Config",
+    "SparkKerberosConfig",
+    "SparkProviderConfig",
+    "SnowflakeConfig",
+    "UpdateProviderRequest",
+    # SecretProvider Types
+    "AWSSecretsManagerSecretConfig",
+    "EnvSecretConfig",
+    "KubernetesSecretConfig",
+    "RegisterSecretProviderRequest",
+    "SecretProvider",
+    "SecretProviderConfig",
+    "SecretProviderType",
+    "UpdateSecretProviderRequest",
+    "VaultSecretConfig",
+]

featureform/_apply_context.py

@@ -0,0 +1,48 @@
+"""Apply-time provider resolution context for resource files."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from featureform.client import Client
+
+
+_active_client: ContextVar[Client | None] = ContextVar(
+    "featureform_active_apply_client",
+    default=None,
+)
+_active_workspace_id: ContextVar[UUID | None] = ContextVar(
+    "featureform_active_apply_workspace_id",
+    default=None,
+)
+
+
+@contextmanager
+def apply_resolution_context(
+    *,
+    client: Client | None,
+    workspace_id: UUID | None,
+) -> Iterator[None]:
+    """Temporarily expose the active apply client/workspace to resource files."""
+    client_token = _active_client.set(client)
+    workspace_token = _active_workspace_id.set(workspace_id)
+    try:
+        yield
+    finally:
+        _active_client.reset(client_token)
+        _active_workspace_id.reset(workspace_token)
+
+
+def get_active_apply_client() -> Client | None:
+    """Return the active apply client, if any."""
+    return _active_client.get()
+
+
+def get_active_apply_workspace_id() -> UUID | None:
+    """Return the active apply workspace ID, if any."""
+    return _active_workspace_id.get()

featureform/_apply_wait.py

@@ -0,0 +1,183 @@
+"""Shared apply wait helpers for CLI and Python client flows."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping
+from enum import Enum
+from typing import Any, cast
+
+
+class WaitTarget(str, Enum):
+    """Wait target options for apply jobs."""
+
+    RUNNING = "running"
+    FINISHED = "finished"
+
+
+TERMINAL_JOB_STATUSES = {"COMPLETED", "COMPLETED_WITH_WARNINGS", "FAILED", "CANCELED"}
+SUCCESSFUL_TERMINAL_JOB_STATUSES = {"COMPLETED", "COMPLETED_WITH_WARNINGS"}
+FAILED_JOB_STATUSES = {"FAILED", "CANCELED"}
+
+
+class ApplyWaitError(Exception):
+    """Raised when apply wait semantics fail or time out."""
+
+
+class ApplyWaitTimeoutError(ApplyWaitError):
+    """Raised when apply waiting exceeds the allotted timeout."""
+
+
+class ApplyJobVisibilityTimeoutError(ApplyWaitTimeoutError):
+    """Timed out before the scheduler job became visible."""
+
+    def __init__(self, job_id: str) -> None:
+        super().__init__(f"Timed out waiting for job '{job_id}' to become visible.")
+        self.job_id = job_id
+
+
+class ApplyJobStateTimeoutError(ApplyWaitTimeoutError):
+    """Timed out before the scheduler job reached the requested wait target."""
+
+    def __init__(self, job_id: str, wait_for: WaitTarget, last_status: str) -> None:
+        super().__init__(
+            f"Timed out waiting for job '{job_id}' to reach {wait_for.value}. "
+            f"Last status: {last_status}."
+        )
+        self.job_id = job_id
+        self.wait_for = wait_for
+        self.last_status = last_status
+
+
+class ApplyJobFailedError(ApplyWaitError):
+    """Apply job reached a failed terminal state."""
+
+    def __init__(
+        self,
+        job_id: str,
+        status: str,
+        *,
+        detail: str | None = None,
+        job: dict[str, Any] | None = None,
+    ) -> None:
+        message = f"Apply job '{job_id}' finished with status {status}."
+        if detail:
+            message = f"{message} {detail}"
+        super().__init__(message)
+        self.job_id = job_id
+        self.status = status
+        self.detail = detail
+        self.job = job
+
+
+class ApplyJobFetchError(ApplyWaitError):
+    """Fetching scheduler job state failed."""
+
+    def __init__(self, job_id: str, detail: str | None = None) -> None:
+        message = f"Failed to fetch apply job '{job_id}'."
+        if detail:
+            message = f"{message} {detail}"
+        super().__init__(message)
+        self.job_id = job_id
+        self.detail = detail
+
+
+class ApplyWorkspaceVersionTimeoutError(ApplyWaitTimeoutError):
+    """Timed out waiting for the applied workspace version to become visible."""
+
+    def __init__(self, workspace_id: object, minimum: int, last_seen: int) -> None:
+        super().__init__(
+            f"Timed out waiting for workspace '{workspace_id}' to reach applied version "
+            f"{minimum}. Last seen version: {last_seen}."
+        )
+        self.workspace_id = workspace_id
+        self.minimum = minimum
+        self.last_seen = last_seen
+
+
+def summarize_failed_job(job: Mapping[str, object]) -> str | None:
+    """Build a concise failure summary from scheduler job data."""
+    parts: list[str] = []
+
+    job_error_value: object = job.get("error_message")
+    job_error = str(job_error_value or "").strip()
+    if job_error:
+        parts.append(f"job error: {job_error}")
+
+    tasks_value: object = job.get("tasks")
+    if isinstance(tasks_value, list):
+        failed_task = next(
+            (
+                task
+                for task in tasks_value
+                if isinstance(task, Mapping)
+                and str(cast(Mapping[str, object], task).get("status", "")).upper() == "FAILED"
+            ),
+            None,
+        )
+        if isinstance(failed_task, Mapping):
+            task = cast(Mapping[str, object], failed_task)
+            task_def_id_value: object = task.get("task_def_id")
+            task_id_value: object = task.get("id")
+            task_error_value: object = task.get("error_message")
+            task_label = str(task_def_id_value or task_id_value or "").strip()
+            task_error = str(task_error_value or "").strip()
+            if task_label:
+                summary = f"failed task: {task_label}"
+                if task_error:
+                    summary = f"{summary}; error: {task_error}"
+                parts.append(summary)
+
+    if not parts:
+        return None
+    return " ".join(parts)
+
+
+def wait_target_reached(status: str, wait_for: WaitTarget) -> bool:
+    """Return whether the current job status satisfies the wait target."""
+    if wait_for == WaitTarget.RUNNING:
+        return status == "RUNNING" or status in SUCCESSFUL_TERMINAL_JOB_STATUSES
+    return status in TERMINAL_JOB_STATUSES
+
+
+def wait_for_job(
+    *,
+    get_job: Callable[[str], dict[str, Any]],
+    job_id: str,
+    wait_for: WaitTarget,
+    timeout_seconds: float,
+    poll_interval_seconds: float,
+    is_not_found_error: Callable[[Exception], bool] | None = None,
+    monotonic_fn: Callable[[], float] = time.monotonic,
+    sleep_fn: Callable[[float], None] = time.sleep,
+) -> dict[str, Any]:
+    """Poll the scheduler until a job reaches the requested state."""
+    deadline = monotonic_fn() + timeout_seconds
+
+    while True:
+        try:
+            job = get_job(job_id)
+        except Exception as exc:
+            if is_not_found_error is not None and is_not_found_error(exc):
+                if monotonic_fn() >= deadline:
+                    raise ApplyJobVisibilityTimeoutError(job_id) from None
+                sleep_fn(poll_interval_seconds)
+                continue
+            raise
+
+        raw_status = job.get("status")
+        status = str(raw_status).upper().strip() if raw_status not in (None, "") else "UNKNOWN"
+        if status in FAILED_JOB_STATUSES:
+            raise ApplyJobFailedError(
+                job_id,
+                status,
+                detail=summarize_failed_job(job),
+                job=job,
+            )
+        if wait_target_reached(status, wait_for):
+            return job
+
+        if monotonic_fn() >= deadline:
+            raise ApplyJobStateTimeoutError(job_id, wait_for, status)
+
+        sleep_fn(poll_interval_seconds)

featureform/_generated/__init__.py

@@ -0,0 +1 @@
+"""Generated code from protobuf and OpenAPI."""

featureform/_generated/openapi/__init__.py

@@ -0,0 +1,13 @@
+# generated by datamodel-codegen:
+#   filename:  swagger.json
+#   timestamp: 2026-04-19T23:23:13+00:00
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import RootModel
+
+
+class Model(RootModel[Any]):
+    root: Any