prefect-client 3.0.0rc1__py3-none-any.whl → 3.0.0rc3__py3-none-any.whl

prefect/_internal/compatibility/migration.py

@@ -0,0 +1,124 @@
+"""
+This module provides a function to handle imports for moved or removed objects in Prefect 3.0 upgrade.
+
+The `getattr_migration` function is used to handle imports for moved or removed objects in Prefect 3.0 upgrade.
+It is used in the `__getattr__` attribute of modules that have moved or removed objects.
+
+Usage:
+```python
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)
+```
+"""
+
+import sys
+from typing import Any, Callable, Dict
+
+from pydantic_core import PydanticCustomError
+
+from prefect.exceptions import PrefectImportError
+
+MOVED_IN_V3 = {
+    "prefect.deployments.deployments:load_flow_from_flow_run": "prefect.flows:load_flow_from_flow_run",
+    "prefect.deployments:load_flow_from_flow_run": "prefect.flows:load_flow_from_flow_run",
+    "prefect.variables:get": "prefect.variables:Variable.get",
+    "prefect.engine:pause_flow_run": "prefect.flow_runs:pause_flow_run",
+    "prefect.engine:resume_flow_run": "prefect.flow_runs:resume_flow_run",
+    "prefect.engine:suspend_flow_run": "prefect.flow_runs:suspend_flow_run",
+    "prefect.engine:_in_process_pause": "prefect.flow_runs:_in_process_pause",
+}
+
+REMOVED_IN_V3 = {
+    "prefect.deployments.deployments:Deployment": "Use 'flow.serve()' or `prefect deploy` instead.",
+    "prefect.deployments:Deployment": "Use 'flow.serve()' or `prefect deploy` instead.",
+    "prefect.filesystems:GCS": "Use 'prefect_gcp' instead.",
+    "prefect.filesystems:Azure": "Use 'prefect_azure' instead.",
+    "prefect.filesystems:S3": "Use 'prefect_aws' instead.",
+    "prefect.engine:_out_of_process_pause": "Use 'prefect.flow_runs.pause_flow_run' instead.",
+}
+
+# IMPORTANT FOR USAGE: When adding new modules to MOVED_IN_V3 or REMOVED_IN_V3, include the following lines at the bottom of that module:
+# from prefect._internal.compatibility.migration import getattr_migration
+# __getattr__ = getattr_migration(__name__)
+# See src/prefect/filesystems.py for an example
+
+
+def import_string_class_method(new_location: str) -> Callable:
+    """
+    Handle moved class methods.
+
+    `import_string` does not account for moved class methods. This function handles cases where a method has been
+    moved to a class. For example, if `new_location` is 'prefect.variables:Variable.get', `import_string(new_location)`
+    will raise an error because it does not handle class methods. This function will import the class and get the
+    method from the class.
+
+    Args:
+        new_location (str): The new location of the method.
+
+    Returns:
+        method: The resolved method from the class.
+
+    Raises:
+        PrefectImportError: If the method is not found in the class.
+    """
+    from pydantic._internal._validators import import_string
+
+    class_name, method_name = new_location.rsplit(".", 1)
+
+    cls = import_string(class_name)
+    method = getattr(cls, method_name, None)
+
+    if method is not None and callable(method):
+        return method
+
+    raise PrefectImportError(f"Unable to import {new_location!r}")
+
+
+def getattr_migration(module_name: str) -> Callable[[str], Any]:
+    """
+    Handle imports for moved or removed objects in Prefect 3.0 upgrade
+
+    Args:
+        module_name (str): The name of the module to handle imports for.
+    """
+
+    def wrapper(name: str) -> object:
+        """
+        Raise a PrefectImportError if the object is not found, moved, or removed.
+        """
+
+        if name == "__path__":
+            raise AttributeError(f"{module_name!r} object has no attribute {name!r}")
+        import warnings
+
+        from pydantic._internal._validators import import_string
+
+        import_path = f"{module_name}:{name}"
+
+        # Check if the attribute name corresponds to a moved or removed class or module
+        if import_path in MOVED_IN_V3.keys():
+            new_location = MOVED_IN_V3[import_path]
+            warnings.warn(
+                f"{import_path!r} has been moved to {new_location!r}. Importing from {new_location!r} instead. This warning will raise an error in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            try:
+                return import_string(new_location)
+            except PydanticCustomError:
+                return import_string_class_method(new_location)
+
+        if import_path in REMOVED_IN_V3.keys():
+            error_message = REMOVED_IN_V3[import_path]
+            raise PrefectImportError(
+                f"{import_path!r} has been removed. {error_message}"
+            )
+
+        globals: Dict[str, Any] = sys.modules[module_name].__dict__
+        if name in globals:
+            return globals[name]
+
+        raise AttributeError(f"module {module_name!r} has no attribute {name!r}")
+
+    return wrapper

prefect/_internal/concurrency/__init__.py

@@ -5,7 +5,7 @@ both asynchronous and synchronous calls.
 Much of the complexity managed here arises from ensuring that a thread of execution is
 not blocked.
 
-The main data structure is a `Call` which is created from a function call capturing 
+The main data structure is a `Call` which is created from a function call capturing
 local context variables. The call is then submitted to run somewhere via a `Portal`.
 The primary portal used is the `WorkerThread`, which executes work on a thread running
 concurrently to the one that created the call. A singleton `EventLoopThread` portal
@@ -13,7 +13,7 @@ is also used to schedule work on a dedicated event loop.
 
 The result of the call can be retrieved asynchronously using `Call.result()`. Behind
 the scenes, a `Future` is used to report the result of the call. Retrieving the result
-of a call is a blocking operation. 
+of a call is a blocking operation.
 
 Sometimes, it is important not to block the current thread while retrieving the result
 of a call. For this purpose, there is the `Waiter`. Waiters attach to a call and provide

prefect/_internal/concurrency/primitives.py

@@ -1,6 +1,7 @@
 """
 Thread-safe async synchronization primitives.
 """
+
 import asyncio
 import collections
 import threading

prefect/_internal/pydantic/annotations/pendulum.py

@@ -1,6 +1,6 @@
 """
-This file contains compat code to handle pendulum.DateTime objects during jsonschema 
-generation and validation. 
+This file contains compat code to handle pendulum.DateTime objects during jsonschema
+generation and validation.
 """
 
 import typing as t

prefect/_internal/pytz.py

@@ -1,5 +1,5 @@
 """
-This is a compatibility module that allows us to drop our dependency on pytz in the minimal prefect-client. 
+This is a compatibility module that allows us to drop our dependency on pytz in the minimal prefect-client.
 
 All values here are taken from:
 

prefect/blocks/core.py

@@ -1122,7 +1122,7 @@ class Block(BaseModel, ABC):
         cls,
         by_alias: bool = True,
         ref_template: str = "#/definitions/{model}",
-        schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
+        schema_generator: Type[GenerateJsonSchema] = GenerateJsonSchema,
         mode: Literal["validation", "serialization"] = "validation",
     ) -> Dict[str, Any]:
         """TODO: stop overriding this method - use GenerateSchema in ConfigDict instead?"""

prefect/blocks/redis.py

@@ -0,0 +1,168 @@
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncGenerator, Optional, Union
+
+try:
+    import redis.asyncio as redis
+except ImportError:
+    raise ImportError(
+        "`redis-py` must be installed to use the `RedisStorageContainer` block. "
+        "You can install it with `pip install redis>=5.0.1"
+    )
+
+from pydantic import Field
+from pydantic.types import SecretStr
+from typing_extensions import Self
+
+from prefect.filesystems import WritableFileSystem
+from prefect.utilities.asyncutils import sync_compatible
+
+
+class RedisStorageContainer(WritableFileSystem):
+    """
+    Block used to interact with Redis as a filesystem
+
+    Attributes:
+        host (str): The value to store.
+        port (int): The value to store.
+        db (int): The value to store.
+        username (str): The value to store.
+        password (str): The value to store.
+        connection_string (str): The value to store.
+
+    Example:
+        Create a new block from hostname, username and password:
+        ```python
+        from prefect.blocks.redis import RedisStorageContainer
+
+        block = RedisStorageContainer.from_host(
+            host="myredishost.com", username="redis", password="SuperSecret")
+        block.save("BLOCK_NAME")
+        ```
+
+        Create a new block from a connection string
+        ```python
+        from prefect.blocks.redis import RedisStorageContainer
+        block = RedisStorageContainer.from_url(""redis://redis:SuperSecret@myredishost.com:6379")
+        block.save("BLOCK_NAME")
+        ```
+    """
+
+    _logo_url = "https://stprododpcmscdnendpoint.azureedge.net/assets/icons/redis.png"
+
+    host: Optional[str] = Field(default=None, description="Redis hostname")
+    port: int = Field(default=6379, description="Redis port")
+    db: int = Field(default=0, description="Redis DB index")
+    username: Optional[SecretStr] = Field(default=None, description="Redis username")
+    password: Optional[SecretStr] = Field(default=None, description="Redis password")
+    connection_string: Optional[SecretStr] = Field(
+        default=None, description="Redis connection string"
+    )
+
+    def block_initialization(self) -> None:
+        if self.connection_string:
+            return
+        if not self.host:
+            raise ValueError("Initialization error: 'host' is required but missing.")
+        if self.username and not self.password:
+            raise ValueError(
+                "Initialization error: 'username' is provided, but 'password' is missing. Both are required."
+            )
+
+    @sync_compatible
+    async def read_path(self, path: Union[Path, str]):
+        """Read the redis content at `path`
+
+        Args:
+            path: Redis key to read from
+
+        Returns:
+            Contents at key as bytes
+        """
+        async with self._client() as client:
+            return await client.get(str(path))
+
+    @sync_compatible
+    async def write_path(self, path: Union[Path, str], content: bytes):
+        """Write `content` to the redis at `path`
+
+        Args:
+            path: Redis key to write to
+            content: Binary object to write
+        """
+
+        async with self._client() as client:
+            return await client.set(str(path), content)
+
+    @asynccontextmanager
+    async def _client(self) -> AsyncGenerator[redis.Redis, None]:
+        if self.connection_string:
+            client = redis.Redis.from_url(self.connection_string.get_secret_value())
+        else:
+            assert self.host
+            client = redis.Redis(
+                host=self.host,
+                port=self.port,
+                username=self.username.get_secret_value() if self.username else None,
+                password=self.password.get_secret_value() if self.password else None,
+                db=self.db,
+            )
+
+        try:
+            yield client
+        finally:
+            await client.aclose()
+
+    @classmethod
+    def from_host(
+        cls,
+        host: str,
+        port: int = 6379,
+        db: int = 0,
+        username: Union[None, str, SecretStr] = None,
+        password: Union[None, str, SecretStr] = None,
+    ) -> Self:
+        """Create block from hostname, username and password
+
+        Args:
+            host: Redis hostname
+            username: Redis username
+            password: Redis password
+            port: Redis port
+
+        Returns:
+            `RedisStorageContainer` instance
+        """
+
+        username = SecretStr(username) if isinstance(username, str) else username
+        password = SecretStr(password) if isinstance(password, str) else password
+
+        return cls(host=host, port=port, db=db, username=username, password=password)
+
+    @classmethod
+    def from_connection_string(cls, connection_string: Union[str, SecretStr]) -> Self:
+        """Create block from a Redis connection string
+
+        Supports the following URL schemes:
+        - `redis://` creates a TCP socket connection
+        - `rediss://` creates a SSL wrapped TCP socket connection
+        - `unix://` creates a Unix Domain Socket connection
+
+        See [Redis docs](https://redis.readthedocs.io/en/stable/examples
+        /connection_examples.html#Connecting-to-Redis-instances-by-specifying-a-URL
+        -scheme.) for more info.
+
+        Args:
+            connection_string: Redis connection string
+
+        Returns:
+            `RedisStorageContainer` instance
+        """
+
+        connection_string = (
+            SecretStr(connection_string)
+            if isinstance(connection_string, str)
+            else connection_string
+        )
+
+        return cls(connection_string=connection_string)

prefect/client/orchestration.py

@@ -8,11 +8,13 @@ from typing import (
     Dict,
     Iterable,
     List,
+    Literal,
     Optional,
     Set,
     Tuple,
     TypeVar,
     Union,
+    overload,
 )
 from uuid import UUID, uuid4
 
@@ -156,9 +158,23 @@ class ServerType(AutoEnum):
     CLOUD = AutoEnum.auto()
 
 
+@overload
+def get_client(
+    httpx_settings: Optional[Dict[str, Any]] = None, sync_client: Literal[False] = False
+) -> "PrefectClient":
+    ...
+
+
+@overload
+def get_client(
+    httpx_settings: Optional[Dict[str, Any]] = None, sync_client: Literal[True] = True
+) -> "SyncPrefectClient":
+    ...
+
+
 def get_client(
     httpx_settings: Optional[Dict[str, Any]] = None, sync_client: bool = False
-) -> Union["PrefectClient", "SyncPrefectClient"]:
+):
     """
     Retrieve a HTTP client for communicating with the Prefect REST API.
 
@@ -254,8 +270,8 @@ class PrefectClient:
         self,
         api: Union[str, ASGIApp],
         *,
-        api_key: str = None,
-        api_version: str = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
         httpx_settings: Optional[Dict[str, Any]] = None,
     ) -> None:
         httpx_settings = httpx_settings.copy() if httpx_settings else {}
@@ -490,7 +506,7 @@ class PrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[Flow]:
         """
@@ -560,12 +576,12 @@ class PrefectClient:
         *,
         parameters: Optional[Dict[str, Any]] = None,
         context: Optional[Dict[str, Any]] = None,
-        state: prefect.states.State = None,
-        name: str = None,
-        tags: Iterable[str] = None,
-        idempotency_key: str = None,
-        parent_task_run_id: UUID = None,
-        work_queue_name: str = None,
+        state: Optional[prefect.states.State] = None,
+        name: Optional[str] = None,
+        tags: Optional[Iterable[str]] = None,
+        idempotency_key: Optional[str] = None,
+        parent_task_run_id: Optional[UUID] = None,
+        work_queue_name: Optional[str] = None,
         job_variables: Optional[Dict[str, Any]] = None,
     ) -> FlowRun:
         """
@@ -1694,7 +1710,7 @@ class PrefectClient:
         self,
         deployment: Deployment,
         schedule: SCHEDULE_TYPES = None,
-        is_schedule_active: bool = None,
+        is_schedule_active: Optional[bool] = None,
     ):
         deployment_update = DeploymentUpdate(
             version=deployment.version,
@@ -2044,7 +2060,7 @@ class PrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:
         """
@@ -2117,7 +2133,6 @@ class PrefectClient:
         state_create = state.to_state_create()
         state_create.state_details.flow_run_id = flow_run_id
         state_create.state_details.transition_id = uuid4()
-        print(repr(state_create))
         try:
             response = await self._client.post(
                 f"/flow_runs/{flow_run_id}/set_state",
@@ -2252,7 +2267,7 @@ class PrefectClient:
         task_run_filter: TaskRunFilter = None,
         deployment_filter: DeploymentFilter = None,
         sort: TaskRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[TaskRun]:
         """
@@ -2516,8 +2531,8 @@ class PrefectClient:
     async def read_logs(
         self,
         log_filter: LogFilter = None,
-        limit: int = None,
-        offset: int = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
         sort: LogSort = LogSort.TIMESTAMP_ASC,
     ) -> List[Log]:
         """
@@ -2848,7 +2863,7 @@ class PrefectClient:
         flow_run_filter: FlowRunFilter = None,
         task_run_filter: TaskRunFilter = None,
         sort: ArtifactSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[Artifact]:
         """
@@ -2888,7 +2903,7 @@ class PrefectClient:
         flow_run_filter: FlowRunFilter = None,
         task_run_filter: TaskRunFilter = None,
         sort: ArtifactCollectionSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[ArtifactCollection]:
         """
@@ -2988,7 +3003,7 @@ class PrefectClient:
             else:
                 raise
 
-    async def read_variables(self, limit: int = None) -> List[Variable]:
+    async def read_variables(self, limit: Optional[int] = None) -> List[Variable]:
         """Reads all variables."""
         response = await self._client.post("/variables/filter", json={"limit": limit})
         return pydantic.TypeAdapter(List[Variable]).validate_python(response.json())
@@ -3355,8 +3370,8 @@ class SyncPrefectClient:
         self,
         api: Union[str, ASGIApp],
         *,
-        api_key: str = None,
-        api_version: str = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
         httpx_settings: Optional[Dict[str, Any]] = None,
     ) -> None:
         httpx_settings = httpx_settings.copy() if httpx_settings else {}
@@ -3653,6 +3668,61 @@ class SyncPrefectClient:
 
         return flow_run
 
+    def update_flow_run(
+        self,
+        flow_run_id: UUID,
+        flow_version: Optional[str] = None,
+        parameters: Optional[dict] = None,
+        name: Optional[str] = None,
+        tags: Optional[Iterable[str]] = None,
+        empirical_policy: Optional[FlowRunPolicy] = None,
+        infrastructure_pid: Optional[str] = None,
+        job_variables: Optional[dict] = None,
+    ) -> httpx.Response:
+        """
+        Update a flow run's details.
+
+        Args:
+            flow_run_id: The identifier for the flow run to update.
+            flow_version: A new version string for the flow run.
+            parameters: A dictionary of parameter values for the flow run. This will not
+                be merged with any existing parameters.
+            name: A new name for the flow run.
+            empirical_policy: A new flow run orchestration policy. This will not be
+                merged with any existing policy.
+            tags: An iterable of new tags for the flow run. These will not be merged with
+                any existing tags.
+            infrastructure_pid: The id of flow run as returned by an
+                infrastructure block.
+
+        Returns:
+            an `httpx.Response` object from the PATCH request
+        """
+        params = {}
+        if flow_version is not None:
+            params["flow_version"] = flow_version
+        if parameters is not None:
+            params["parameters"] = parameters
+        if name is not None:
+            params["name"] = name
+        if tags is not None:
+            params["tags"] = tags
+        if empirical_policy is not None:
+            params["empirical_policy"] = empirical_policy.model_dump(
+                mode="json", exclude_unset=True
+            )
+        if infrastructure_pid:
+            params["infrastructure_pid"] = infrastructure_pid
+        if job_variables is not None:
+            params["job_variables"] = job_variables
+
+        flow_run_data = FlowRunUpdate(**params)
+
+        return self._client.patch(
+            f"/flow_runs/{flow_run_id}",
+            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
+        )
+
     def read_flow_run(self, flow_run_id: UUID) -> FlowRun:
         """
         Query the Prefect API for a flow run by id.
@@ -3682,7 +3752,7 @@ class SyncPrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:
         """
@@ -3874,7 +3944,7 @@ class SyncPrefectClient:
         task_run_filter: TaskRunFilter = None,
         deployment_filter: DeploymentFilter = None,
         sort: TaskRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[TaskRun]:
         """
@@ -3978,3 +4048,23 @@ class SyncPrefectClient:
             else:
                 raise
         return DeploymentResponse.model_validate(response.json())
+
+    def create_artifact(
+        self,
+        artifact: ArtifactCreate,
+    ) -> Artifact:
+        """
+        Creates an artifact with the provided configuration.
+
+        Args:
+            artifact: Desired configuration for the new artifact.
+        Returns:
+            Information about the newly created artifact.
+        """
+
+        response = self._client.post(
+            "/artifacts/",
+            json=artifact.model_dump_json(exclude_unset=True),
+        )
+
+        return Artifact.model_validate(response.json())

prefect/client/schemas/actions.py

@@ -788,6 +788,6 @@ class GlobalConcurrencyLimitUpdate(ActionBaseModel):
 
     name: Optional[Name] = Field(None)
     limit: Optional[NonNegativeInteger] = Field(None)
-    active: Optional[NonNegativeInteger] = Field(None)
+    active: Optional[bool] = Field(None)
     active_slots: Optional[NonNegativeInteger] = Field(None)
     slot_decay_per_second: Optional[NonNegativeFloat] = Field(None)

prefect/client/schemas/filters.py

@@ -166,12 +166,18 @@ class FlowRunFilterStateType(PrefectBaseModel):
     any_: Optional[List[StateType]] = Field(
         default=None, description="A list of flow run state types to include"
     )
+    not_any_: Optional[List[StateType]] = Field(
+        default=None, description="A list of flow run state types to exclude"
+    )
 
 
 class FlowRunFilterStateName(PrefectBaseModel):
     any_: Optional[List[str]] = Field(
         default=None, description="A list of flow run state names to include"
     )
+    not_any_: Optional[List[str]] = Field(
+        default=None, description="A list of flow run state names to exclude"
+    )
 
 
 class FlowRunFilterState(PrefectBaseModel, OperatorMixin):