prefect-client 2.20.4__py3-none-any.whl → 3.0.0__py3-none-any.whl

prefect/input/__init__.py

@@ -12,6 +12,8 @@ from .run_input import (
     RunInputMetadata,
     keyset_from_base_key,
     keyset_from_paused_state,
+    receive_input,
+    send_input,
 )
 
 __all__ = [
@@ -26,4 +28,6 @@ __all__ = [
     "keyset_from_base_key",
     "keyset_from_paused_state",
     "read_flow_run_input",
+    "receive_input",
+    "send_input",
 ]

prefect/input/actions.py

@@ -4,7 +4,6 @@ from uuid import UUID
 import orjson
 import pydantic
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect.client.utilities import client_injector
 from prefect.context import FlowRunContext
 from prefect.exceptions import PrefectHTTPStatusError
@@ -14,8 +13,7 @@ if TYPE_CHECKING:
     from prefect.client.orchestration import PrefectClient
 
 
-if HAS_PYDANTIC_V2:
-    from prefect._internal.pydantic.v2_schema import is_v2_model
+from prefect._internal.pydantic.v2_schema import is_v2_model
 
 
 def ensure_flow_run_id(flow_run_id: Optional[UUID] = None) -> UUID:
@@ -41,7 +39,7 @@ async def create_flow_run_input_from_model(
         if context is not None and context.flow_run is not None:
             sender = f"prefect.flow-run.{context.flow_run.id}"
 
-    if HAS_PYDANTIC_V2 and is_v2_model(model_instance):
+    if is_v2_model(model_instance):
         json_safe = orjson.loads(model_instance.model_dump_json())
     else:
         json_safe = orjson.loads(model_instance.json())

prefect/input/run_input.py

@@ -18,7 +18,8 @@ Sender flow:
 ```python
 import random
 from uuid import UUID
-from prefect import flow, get_run_logger
+from prefect import flow
+from prefect.logging import get_run_logger
 from prefect.input import RunInput
 
 class NumberData(RunInput):
@@ -43,7 +44,8 @@ Receiver flow:
 ```python
 import random
 from uuid import UUID
-from prefect import flow, get_run_logger
+from prefect import flow
+from prefect.logging import get_run_logger
 from prefect.input import RunInput
 
 class NumberData(RunInput):
@@ -77,8 +79,8 @@ from uuid import UUID, uuid4
 
 import anyio
 import pydantic
+from pydantic import ConfigDict
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect.input.actions import (
     create_flow_run_input,
     create_flow_run_input_from_model,
@@ -92,8 +94,7 @@ if TYPE_CHECKING:
     from prefect.client.schemas.objects import FlowRunInput
     from prefect.states import State
 
-if HAS_PYDANTIC_V2:
-    from prefect._internal.pydantic.v2_schema import create_v2_schema
+from prefect._internal.pydantic.v2_schema import create_v2_schema, is_v2_model
 
 R = TypeVar("R", bound="RunInput")
 T = TypeVar("T", bound="object")
@@ -138,13 +139,12 @@ def keyset_from_base_key(base_key: str) -> Keyset:
 
 class RunInputMetadata(pydantic.BaseModel):
     key: str
-    sender: Optional[str]
+    sender: Optional[str] = None
     receiver: UUID
 
 
 class RunInput(pydantic.BaseModel):
-    class Config:
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")
 
     _description: Optional[str] = pydantic.PrivateAttr(default=None)
     _metadata: RunInputMetadata = pydantic.PrivateAttr()
@@ -168,7 +168,7 @@ class RunInput(pydantic.BaseModel):
             - flow_run_id (UUID, optional): the flow run ID to save the input for
         """
 
-        if HAS_PYDANTIC_V2:
+        if is_v2_model(cls):
             schema = create_v2_schema(cls.__name__, model_base=cls)
         else:
             schema = cls.schema(by_alias=True)

prefect/logging/formatters.py

@@ -48,7 +48,6 @@ class JsonFormatter(logging.Formatter):
 
         self.serializer = JSONSerializer(
             jsonlib="orjson",
-            object_encoder="pydantic.json.pydantic_encoder",
             dumps_kwargs={"option": orjson.OPT_INDENT_2} if fmt == "pretty" else {},
         )
 
@@ -79,8 +78,8 @@ class PrefectFormatter(logging.Formatter):
         validate=True,
         *,
         defaults=None,
-        task_run_fmt: str = None,
-        flow_run_fmt: str = None,
+        task_run_fmt: Optional[str] = None,
+        flow_run_fmt: Optional[str] = None,
     ) -> None:
         """
         Implementation of the standard Python formatter with support for multiple
@@ -98,7 +97,6 @@ class PrefectFormatter(logging.Formatter):
             init_kwargs["defaults"] = defaults
             style_kwargs["defaults"] = defaults
 
-        # validate added in 3.8
         init_kwargs["validate"] = validate
 
         super().__init__(format, datefmt, style, **init_kwargs)

prefect/logging/handlers.py

@@ -108,8 +108,8 @@ class APILogHandler(logging.Handler):
                 )
 
             # Not ideal, but this method is called by the stdlib and cannot return a
-            # coroutine so we just schedule the drain in a new thread and continue
-            from_sync.call_soon_in_new_thread(create_call(APILogWorker.drain_all))
+            # coroutine so we just schedule the drain in the global loop thread and continue
+            from_sync.call_soon_in_loop_thread(create_call(APILogWorker.drain_all))
             return None
         else:
             # We set a timeout of 5s because we don't want to block forever if the worker
@@ -119,21 +119,13 @@ class APILogHandler(logging.Handler):
             return APILogWorker.drain_all(timeout=5)
 
     @classmethod
-    def aflush(cls):
+    async def aflush(cls):
         """
         Tell the `APILogWorker` to send any currently enqueued logs and block until
         completion.
-
-        If called in a synchronous context, will only block up to 5s before returning.
         """
 
-        if not get_running_loop():
-            raise RuntimeError(
-                "`aflush` cannot be used from a synchronous context; use `flush`"
-                " instead."
-            )
-
-        return APILogWorker.drain_all()
+        return await APILogWorker.drain_all()
 
     def emit(self, record: logging.LogRecord):
         """
@@ -165,7 +157,10 @@ class APILogHandler(logging.Handler):
             if log_handling_when_missing_flow == "warn":
                 # Warn when a logger is used outside of a run context, the stack level here
                 # gets us to the user logging call
-                warnings.warn(str(exc), stacklevel=8)
+                warnings.warn(
+                    f"{exc} Set PREFECT_LOGGING_TO_API_WHEN_MISSING_FLOW=ignore to suppress this warning.",
+                    stacklevel=8,
+                )
                 return
             elif log_handling_when_missing_flow == "ignore":
                 return
@@ -229,7 +224,7 @@ class APILogHandler(logging.Handler):
                 getattr(record, "created", None) or time.time()
             ),
             message=self.format(record),
-        ).dict(json_compatible=True)
+        ).model_dump(mode="json")
 
         log_size = log["__payload_size__"] = self._get_payload_size(log)
         if log_size > PREFECT_LOGGING_TO_API_MAX_LOG_SIZE.value():

prefect/logging/loggers.py

@@ -5,7 +5,7 @@ import warnings
 from builtins import print
 from contextlib import contextmanager
 from functools import lru_cache
-from logging import LogRecord
+from logging import LoggerAdapter, LogRecord
 from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
 from typing_extensions import Self
@@ -69,7 +69,7 @@ class PrefectLogAdapter(logging.LoggerAdapter):
 
 
 @lru_cache()
-def get_logger(name: str = None) -> logging.Logger:
+def get_logger(name: Optional[str] = None) -> logging.Logger:
     """
     Get a `prefect` logger. These loggers are intended for internal use within the
     `prefect` package.
@@ -97,7 +97,7 @@ def get_logger(name: str = None) -> logging.Logger:
 
 
 def get_run_logger(
-    context: "RunContext" = None, **kwargs: str
+    context: Optional["RunContext"] = None, **kwargs: str
 ) -> Union[logging.Logger, logging.LoggerAdapter]:
     """
     Get a Prefect logger for the current task run or flow run.
@@ -115,7 +115,7 @@ def get_run_logger(
             addition to the run metadata
 
     Raises:
-        RuntimeError: If no context can be found
+        MissingContextError: If no context can be found
     """
     # Check for existing contexts
     task_run_context = prefect.context.TaskRunContext.get()
@@ -161,7 +161,7 @@ def flow_run_logger(
     flow_run: Union["FlowRun", "ClientFlowRun"],
     flow: Optional["Flow"] = None,
     **kwargs: str,
-):
+) -> LoggerAdapter:
     """
     Create a flow run logger with the run's metadata attached.
 

prefect/main.py

@@ -0,0 +1,72 @@
+# Import user-facing API
+from prefect.deployments import deploy
+from prefect.states import State
+from prefect.logging import get_run_logger
+from prefect.flows import flow, Flow, serve
+from prefect.transactions import Transaction
+from prefect.tasks import task, Task
+from prefect.context import tags
+from prefect.utilities.annotations import unmapped, allow_failure
+from prefect.results import BaseResult
+from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
+from prefect.client.orchestration import get_client, PrefectClient
+from prefect.client.cloud import get_cloud_client, CloudClient
+import prefect.variables
+import prefect.runtime
+
+# Import modules that register types
+import prefect.serializers
+import prefect.blocks.notifications
+import prefect.blocks.system
+
+# Initialize the process-wide profile and registry at import time
+import prefect.context
+
+# Perform any forward-ref updates needed for Pydantic models
+import prefect.client.schemas
+
+prefect.context.FlowRunContext.model_rebuild(
+    _types_namespace={"Flow": Flow, "BaseResult": BaseResult}
+)
+prefect.context.TaskRunContext.model_rebuild(_types_namespace={"Task": Task})
+prefect.client.schemas.State.model_rebuild(_types_namespace={"BaseResult": BaseResult})
+prefect.client.schemas.StateCreate.model_rebuild(
+    _types_namespace={"BaseResult": BaseResult}
+)
+Transaction.model_rebuild()
+
+# Configure logging
+import prefect.logging.configuration
+
+prefect.logging.configuration.setup_logging()
+prefect.logging.get_logger("profiles").debug(
+    f"Using profile {prefect.context.get_settings_context().profile.name!r}"
+)
+
+
+from prefect._internal.compatibility.deprecated import (
+    inject_renamed_module_alias_finder,
+)
+
+inject_renamed_module_alias_finder()
+
+
+# Declare API for type-checkers
+__all__ = [
+    "allow_failure",
+    "flow",
+    "Flow",
+    "get_client",
+    "get_run_logger",
+    "State",
+    "tags",
+    "task",
+    "Task",
+    "Transaction",
+    "unmapped",
+    "serve",
+    "deploy",
+    "pause_flow_run",
+    "resume_flow_run",
+    "suspend_flow_run",
+]

prefect/plugins.py

@@ -7,12 +7,12 @@ Currently supported entrypoints:
     - prefect.collections: Identifies this package as a Prefect collection that
         should be imported when Prefect is imported.
 """
-import sys
+
 from types import ModuleType
 from typing import Any, Dict, Union
 
 import prefect.settings
-from prefect.utilities.compat import EntryPoint, EntryPoints, entry_points
+from prefect.utilities.compat import EntryPoints, entry_points
 
 
 def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception, Any]]:
@@ -38,68 +38,6 @@ def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception
     return results
 
 
-def load_extra_entrypoints() -> Dict[str, Union[Exception, Any]]:
-    # Note: Return values are only exposed for testing.
-    results = {}
-
-    if not prefect.settings.PREFECT_EXTRA_ENTRYPOINTS.value():
-        return results
-
-    values = {
-        value.strip()
-        for value in prefect.settings.PREFECT_EXTRA_ENTRYPOINTS.value().split(",")
-    }
-
-    entrypoints = []
-    for value in values:
-        try:
-            entrypoint = EntryPoint(name=None, value=value, group="prefect-extra")
-        except Exception as exc:
-            print(
-                (
-                    f"Warning! Failed to parse extra entrypoint {value!r}:"
-                    f" {type(exc).__name__}: {exc}"
-                ),
-                file=sys.stderr,
-            )
-            results[value] = exc
-        else:
-            entrypoints.append(entrypoint)
-
-    for value, result in zip(
-        values, safe_load_entrypoints(EntryPoints(entrypoints)).values()
-    ):
-        results[value] = result
-
-        if isinstance(result, Exception):
-            print(
-                (
-                    f"Warning! Failed to load extra entrypoint {value!r}:"
-                    f" {type(result).__name__}: {result}"
-                ),
-                file=sys.stderr,
-            )
-        elif callable(result):
-            try:
-                results[value] = result()
-            except Exception as exc:
-                print(
-                    (
-                        f"Warning! Failed to run callable entrypoint {value!r}:"
-                        f" {type(exc).__name__}: {exc}"
-                    ),
-                    file=sys.stderr,
-                )
-                results[value] = exc
-        else:
-            if prefect.settings.PREFECT_DEBUG_MODE:
-                print(
-                    "Loaded extra entrypoint {value!r} successfully.", file=sys.stderr
-                )
-
-    return results
-
-
 def load_prefect_collections() -> Dict[str, ModuleType]:
     """
     Load all Prefect collections that define an entrypoint in the group

prefect/profiles.toml

@@ -1,3 +1,17 @@
-active = "default"
+# This is a template for profile configuration for Prefect.
+# You can modify these profiles or create new ones to suit your needs.
 
-[profiles.default]
+active = "ephemeral"
+
+[profiles.ephemeral]
+PREFECT_SERVER_ALLOW_EPHEMERAL_MODE = "true"
+
+[profiles.local]
+# You will need to set these values appropriately for your local development environment
+PREFECT_API_URL = "http://127.0.0.1:4200/api"
+
+[profiles.test]
+PREFECT_SERVER_ALLOW_EPHEMERAL_MODE = "true"
+PREFECT_API_DATABASE_CONNECTION_URL = "sqlite+aiosqlite:///:memory:"
+
+[profiles.cloud]

prefect/records/__init__.py

@@ -0,0 +1 @@
+from .base import RecordStore

prefect/records/base.py

@@ -0,0 +1,223 @@
+import abc
+import os
+import socket
+import threading
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from prefect.results import BaseResult
+    from prefect.transactions import IsolationLevel
+
+
+@dataclass
+class TransactionRecord:
+    """
+    A dataclass representation of a transaction record.
+    """
+
+    key: str
+    result: "BaseResult"
+
+
+class RecordStore(abc.ABC):
+    @abc.abstractmethod
+    def read(
+        self, key: str, holder: Optional[str] = None
+    ) -> Optional[TransactionRecord]:
+        """
+        Read the transaction record with the given key.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock. If a lock exists on
+                the record being written, the read will be blocked until the lock is
+                released if the provided holder does not match the holder of the lock.
+                If not provided, a default holder based on the current host, process,
+                and thread will be used.
+
+        Returns:
+            TransactionRecord: The transaction record with the given key.
+        """
+        ...
+
+    @abc.abstractmethod
+    def write(self, key: str, result: "BaseResult", holder: Optional[str] = None):
+        """
+        Write the transaction record with the given key.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            record: The transaction record to write.
+            holder: Unique identifier for the holder of the lock. If a lock exists on
+                the record being written, the write will be rejected if the provided
+                holder does not match the holder of the lock. If not provided,
+                a default holder based on the current host, process, and thread will
+                be used.
+        """
+        ...
+
+    @abc.abstractmethod
+    def exists(self, key: str) -> bool:
+        """
+        Check if the transaction record with the given key exists.
+
+        Args:
+            key: Unique identifier for the transaction record.
+
+        Returns:
+            bool: True if the record exists; False otherwise.
+        """
+        ...
+
+    @abc.abstractmethod
+    def supports_isolation_level(self, isolation_level: "IsolationLevel") -> bool:
+        """
+        Check if the record store supports the given isolation level.
+
+        Args:
+            isolation_level: The isolation level to check.
+
+        Returns:
+            bool: True if the record store supports the isolation level; False otherwise.
+        """
+        ...
+
+    def acquire_lock(
+        self,
+        key: str,
+        holder: Optional[str] = None,
+        acquire_timeout: Optional[float] = None,
+        hold_timeout: Optional[float] = None,
+    ) -> bool:
+        """
+        Acquire a lock for a transaction record with the given key. Will block other
+        actors from updating this transaction record until the lock is
+        released.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock. If not provided,
+                a default holder based on the current host, process, and thread will
+                be used.
+            acquire_timeout: Max number of seconds to wait for the record to become
+                available if it is locked while attempting to acquire a lock. Pass 0
+                to attempt to acquire a lock without waiting. Blocks indefinitely by
+                default.
+            hold_timeout: Max number of seconds to hold the lock for. Holds the lock
+                indefinitely by default.
+
+        Returns:
+            bool: True if the lock was successfully acquired; False otherwise.
+        """
+        raise NotImplementedError
+
+    def release_lock(self, key: str, holder: Optional[str] = None):
+        """
+        Releases the lock on the corresponding transaction record.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock. Must match the
+                holder provided when acquiring the lock.
+        """
+        raise NotImplementedError
+
+    def is_locked(self, key: str) -> bool:
+        """
+        Simple check to see if the corresponding record is currently locked.
+
+        Args:
+            key: Unique identifier for the transaction record.
+
+        Returns:
+            True is the record is locked; False otherwise.
+        """
+        raise NotImplementedError
+
+    def is_lock_holder(self, key: str, holder: Optional[str] = None) -> bool:
+        """
+        Check if the current holder is the lock holder for the transaction record.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock. If not provided,
+                a default holder based on the current host, process, and thread will
+                be used.
+
+        Returns:
+            bool: True if the current holder is the lock holder; False otherwise.
+        """
+        raise NotImplementedError
+
+    def wait_for_lock(self, key: str, timeout: Optional[float] = None) -> bool:
+        """
+        Wait for the corresponding transaction record to become free.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            timeout: Maximum time to wait. None means to wait indefinitely.
+
+        Returns:
+            bool: True if the lock becomes free within the timeout; False
+                otherwise.
+        """
+        ...
+
+    @staticmethod
+    def generate_default_holder() -> str:
+        """
+        Generate a default holder string using hostname, PID, and thread ID.
+
+        Returns:
+            str: A unique identifier string.
+        """
+        hostname = socket.gethostname()
+        pid = os.getpid()
+        thread_name = threading.current_thread().name
+        thread_id = threading.get_ident()
+        return f"{hostname}:{pid}:{thread_id}:{thread_name}"
+
+    @contextmanager
+    def lock(
+        self,
+        key: str,
+        holder: Optional[str] = None,
+        acquire_timeout: Optional[float] = None,
+        hold_timeout: Optional[float] = None,
+    ):
+        """
+        Context manager to lock the transaction record during the execution
+        of the nested code block.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock. If not provided,
+                a default holder based on the current host, process, and thread will
+                be used.
+            acquire_timeout: Max number of seconds to wait for the record to become
+                available if it is locked while attempting to acquire a lock. Pass 0
+                to attempt to acquire a lock without waiting. Blocks indefinitely by
+                default.
+            hold_timeout: Max number of seconds to hold the lock for. Holds the lock
+                indefinitely by default.
+
+        Example:
+            Hold a lock while during an operation:
+                ```python
+                    with TransactionRecord(key="my-transaction-record-key").lock():
+                        do_stuff()
+                ```
+        """
+        self.acquire_lock(
+            key=key,
+            holder=holder,
+            acquire_timeout=acquire_timeout,
+            hold_timeout=hold_timeout,
+        )
+
+        try:
+            yield
+        finally:
+            self.release_lock(key=key, holder=holder)