prefect-client 2.17.1__py3-none-any.whl → 2.18.1__py3-none-any.whl

prefect/types/__init__.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+from typing import Any, Callable, ClassVar, Generator
+
+from pydantic_core import core_schema, CoreSchema, SchemaValidator
+from typing_extensions import Self
+from datetime import timedelta
+
+
+@dataclass
+class NonNegativeInteger(int):
+    schema: ClassVar[CoreSchema] = core_schema.int_schema(ge=0)
+
+    @classmethod
+    def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]:
+        yield cls.validate
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Callable[..., Any]
+    ) -> CoreSchema:
+        return cls.schema
+
+    @classmethod
+    def validate(cls, v: Any) -> Self:
+        return SchemaValidator(schema=cls.schema).validate_python(v)
+
+
+@dataclass
+class PositiveInteger(int):
+    schema: ClassVar[CoreSchema] = core_schema.int_schema(gt=0)
+
+    @classmethod
+    def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]:
+        yield cls.validate
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Callable[..., Any]
+    ) -> CoreSchema:
+        return cls.schema
+
+    @classmethod
+    def validate(cls, v: Any) -> Self:
+        return SchemaValidator(schema=cls.schema).validate_python(v)
+
+
+@dataclass
+class NonNegativeDuration(timedelta):
+    schema: ClassVar = core_schema.timedelta_schema(ge=timedelta(seconds=0))
+
+    @classmethod
+    def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]:
+        yield cls.validate
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Callable[..., Any]
+    ) -> CoreSchema:
+        return cls.schema
+
+    @classmethod
+    def validate(cls, v: Any) -> Self:
+        return SchemaValidator(schema=cls.schema).validate_python(v)
+
+
+@dataclass
+class PositiveDuration(timedelta):
+    schema: ClassVar = core_schema.timedelta_schema(gt=timedelta(seconds=0))
+
+    @classmethod
+    def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]:
+        yield cls.validate
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Callable[..., Any]
+    ) -> CoreSchema:
+        return cls.schema
+
+    @classmethod
+    def validate(cls, v: Any) -> Self:
+        return SchemaValidator(schema=cls.schema).validate_python(v)
+
+
+__all__ = [
+    "NonNegativeInteger",
+    "PositiveInteger",
+    "NonNegativeDuration",
+    "PositiveDuration",
+]

prefect/utilities/asyncutils.py

@@ -1,11 +1,13 @@
 """
 Utilities for interoperability with async functions and workers from various contexts.
 """
+
 import asyncio
 import ctypes
 import inspect
 import threading
 import warnings
+from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
 from functools import partial, wraps
 from threading import Thread
@@ -78,6 +80,41 @@ def is_async_gen_fn(func):
     return inspect.isasyncgenfunction(func)
 
 
+def run_sync(coroutine: Coroutine[Any, Any, T]) -> T:
+    """
+    Runs a coroutine from a synchronous context, either in the current event
+    loop or in a new one if there is no event loop running. The coroutine will
+    block until it is done. A thread will be spawned to run the event loop if
+    necessary, which allows coroutines to run in environments like Jupyter
+    notebooks where the event loop runs on the main thread.
+
+    Args:
+        coroutine: The coroutine to run.
+
+    Returns:
+        The return value of the coroutine.
+
+    Example:
+        Basic usage:
+        ```python
+        async def my_async_function(x: int) -> int:
+            return x + 1
+
+        run_sync(my_async_function(1))
+        ```
+    """
+    try:
+        loop = asyncio.get_running_loop()
+        if loop.is_running():
+            with ThreadPoolExecutor() as executor:
+                future = executor.submit(asyncio.run, coroutine)
+                return future.result()
+        else:
+            return asyncio.run(coroutine)
+    except RuntimeError:
+        return asyncio.run(coroutine)
+
+
 async def run_sync_in_worker_thread(
     __fn: Callable[..., T], *args: Any, **kwargs: Any
 ) -> T:

prefect/utilities/engine.py

@@ -11,6 +11,7 @@ from typing import (
     Iterable,
     Optional,
     Set,
+    TypeVar,
     Union,
 )
 from uuid import UUID, uuid4
@@ -66,6 +67,7 @@ from prefect.utilities.text import truncated_to
 API_HEALTHCHECKS = {}
 UNTRACKABLE_TYPES = {bool, type(None), type(...), type(NotImplemented)}
 engine_logger = get_logger("engine")
+T = TypeVar("T")
 
 
 async def collect_task_run_inputs(expr: Any, max_depth: int = -1) -> Set[TaskRunInput]:
@@ -308,11 +310,11 @@ async def resolve_inputs(
 
 async def propose_state(
     client: PrefectClient,
-    state: State,
+    state: State[object],
     force: bool = False,
-    task_run_id: UUID = None,
-    flow_run_id: UUID = None,
-) -> State:
+    task_run_id: Optional[UUID] = None,
+    flow_run_id: Optional[UUID] = None,
+) -> State[object]:
     """
     Propose a new state for a flow run or task run, invoking Prefect orchestration logic.
 

prefect/utilities/pydantic.py

@@ -1,24 +1,25 @@
 from functools import partial
-from typing import Any, Callable, Generic, Type, TypeVar, cast, overload
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
+from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar, cast, overload
 
 from jsonpatch import JsonPatch as JsonPatchBase
+from pydantic_core import to_jsonable_python
 from typing_extensions import Self
 
+from prefect._internal.pydantic.utilities.model_dump import model_dump
+from prefect.pydantic import HAS_PYDANTIC_V2
 from prefect.utilities.dispatch import get_dispatch_key, lookup_type, register_base_type
 from prefect.utilities.importtools import from_qualified_name, to_qualified_name
 
+if HAS_PYDANTIC_V2:
+    import pydantic.v1 as pydantic_v1
+else:
+    import pydantic as pydantic_v1
+
 D = TypeVar("D", bound=Any)
-M = TypeVar("M", bound=pydantic.BaseModel)
+M = TypeVar("M", bound=pydantic_v1.BaseModel)
 
 
-def _reduce_model(model: pydantic.BaseModel):
+def _reduce_model(model: pydantic_v1.BaseModel):
     """
     Helper for serializing a cythonized model with cloudpickle.
 
@@ -82,7 +83,7 @@ def add_cloudpickle_reduction(__model_cls: Type[M] = None, **kwargs: Any):
         )
 
 
-def get_class_fields_only(model: Type[pydantic.BaseModel]) -> set:
+def get_class_fields_only(model: Type[pydantic_v1.BaseModel]) -> set:
     """
     Gets all the field names defined on the model class but not any parent classes.
     Any fields that are on the parent but redefined on the subclass are included.
@@ -91,7 +92,7 @@ def get_class_fields_only(model: Type[pydantic.BaseModel]) -> set:
     parent_class_fields = set()
 
     for base in model.__class__.__bases__:
-        if issubclass(base, pydantic.BaseModel):
+        if issubclass(base, pydantic_v1.BaseModel):
             parent_class_fields.update(base.__annotations__.keys())
 
     return (subclass_class_fields - parent_class_fields) | (
@@ -134,7 +135,7 @@ def add_type_dispatch(model_cls: Type[M]) -> Type[M]:
 
     elif defines_dispatch_key and not defines_type_field:
         # Add a type field to store the value of the dispatch key
-        model_cls.__fields__["type"] = pydantic.fields.ModelField(
+        model_cls.__fields__["type"] = pydantic_v1.fields.ModelField(
             name="type",
             type_=str,
             required=True,
@@ -180,7 +181,7 @@ def add_type_dispatch(model_cls: Type[M]) -> Type[M]:
             try:
                 subcls = lookup_type(cls, dispatch_key=kwargs["type"])
             except KeyError as exc:
-                raise pydantic.ValidationError(errors=[exc], model=cls)
+                raise pydantic_v1.ValidationError(errors=[exc], model=cls)
             return cls_new(subcls)
         else:
             return cls_new(cls)
@@ -206,7 +207,7 @@ class PartialModel(Generic[M]):
     a field already has a value.
 
     Example:
-        >>> class MyModel(pydantic.BaseModel):
+        >>> class MyModel(pydantic_v1.BaseModel):
         >>>     x: int
         >>>     y: str
         >>>     z: float
@@ -267,3 +268,21 @@ class JsonPatch(JsonPatchBase):
                 },
             }
         )
+
+
+def custom_pydantic_encoder(
+    type_encoders: Optional[Dict[Any, Callable[[Type[Any]], Any]]], obj: Any
+) -> Any:
+    # Check the class type and its superclasses for a matching encoder
+    for base in obj.__class__.__mro__[:-1]:
+        try:
+            encoder = type_encoders[base]
+        except KeyError:
+            continue
+
+        return encoder(obj)
+    else:  # We have exited the for loop without finding a suitable encoder
+        if isinstance(obj, pydantic_v1.BaseModel):
+            return model_dump(obj, mode="json")
+        else:
+            return to_jsonable_python(obj)

prefect/utilities/schema_tools/hydration.py

@@ -1,41 +1,53 @@
 import json
 from typing import Any, Callable, Dict, Optional
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel, Field
-else:
-    from pydantic import BaseModel, Field
-
+import jinja2
+from pydantic import BaseModel, Field
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing_extensions import TypeAlias
 
-from prefect.server.models.variables import read_variables
+from prefect.server.utilities.user_templates import (
+    TemplateSecurityError,
+    render_user_template_sync,
+    validate_user_template,
+)
 
 
 class HydrationContext(BaseModel):
     workspace_variables: Dict[str, str] = Field(default_factory=dict)
+    render_workspace_variables: bool = Field(default=False)
     raise_on_error: bool = Field(default=False)
+    render_jinja: bool = Field(default=False)
+    jinja_context: Dict[str, Any] = Field(default_factory=dict)
 
     @classmethod
     async def build(
         cls,
         session: AsyncSession,
         raise_on_error: bool = False,
+        render_jinja: bool = False,
+        render_workspace_variables: bool = False,
     ) -> "HydrationContext":
-        variables = await read_variables(
-            session=session,
-        )
+        from prefect.server.models.variables import read_variables
+
+        if render_workspace_variables:
+            variables = await read_variables(
+                session=session,
+            )
+        else:
+            variables = []
+
         return cls(
             workspace_variables={
                 variable.name: variable.value for variable in variables
             },
             raise_on_error=raise_on_error,
+            render_jinja=render_jinja,
+            render_workspace_variables=render_workspace_variables,
         )
 
 
-Handler: TypeAlias = Callable[[Dict, HydrationContext], Any]
+Handler: TypeAlias = Callable[[dict, HydrationContext], Any]
 PrefectKind: TypeAlias = Optional[str]
 
 _handlers: Dict[PrefectKind, Handler] = {}
@@ -93,6 +105,12 @@ class ValueNotFound(KeyNotFound):
         return "value"
 
 
+class TemplateNotFound(KeyNotFound):
+    @property
+    def key(self):
+        return "template"
+
+
 class VariableNameNotFound(KeyNotFound):
     @property
     def key(self):
@@ -108,6 +126,15 @@ class InvalidJSON(HydrationError):
         return message
 
 
+class InvalidJinja(HydrationError):
+    @property
+    def message(self):
+        message = "Invalid jinja"
+        if self.detail:
+            message += f": {self.detail}"
+        return message
+
+
 class WorkspaceVariableNotFound(HydrationError):
     @property
     def variable_name(self) -> str:
@@ -116,7 +143,25 @@ class WorkspaceVariableNotFound(HydrationError):
 
     @property
     def message(self):
-        return f"Variable '{self.detail}' not found."
+        return f"Variable '{self.detail}' not found in workspace."
+
+
+class WorkspaceVariable(Placeholder):
+    def __init__(self, variable_name: str):
+        self.variable_name = variable_name
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, type(self)) and self.variable_name == other.variable_name
+        )
+
+
+class ValidJinja(Placeholder):
+    def __init__(self, template: str):
+        self.template = template
+
+    def __eq__(self, other):
+        return isinstance(other, type(self)) and self.template == other.template
 
 
 def handler(kind: PrefectKind) -> Callable:
@@ -127,7 +172,7 @@ def handler(kind: PrefectKind) -> Callable:
     return decorator
 
 
-def call_handler(kind: PrefectKind, obj: Dict, ctx: HydrationContext) -> Any:
+def call_handler(kind: PrefectKind, obj: dict, ctx: HydrationContext) -> Any:
     if kind not in _handlers:
         return (obj or {}).get("value", None)
 
@@ -138,7 +183,7 @@ def call_handler(kind: PrefectKind, obj: Dict, ctx: HydrationContext) -> Any:
 
 
 @handler("none")
-def null_handler(obj: Dict, ctx: HydrationContext):
+def null_handler(obj: dict, ctx: HydrationContext):
     if "value" in obj:
         # null handler is a pass through, so we want to continue to hydrate
         return _hydrate(obj["value"], ctx)
@@ -147,7 +192,7 @@ def null_handler(obj: Dict, ctx: HydrationContext):
 
 
 @handler("json")
-def json_handler(obj: Dict, ctx: HydrationContext):
+def json_handler(obj: dict, ctx: HydrationContext):
     if "value" in obj:
         if isinstance(obj["value"], dict):
             dehydrated_json = _hydrate(obj["value"], ctx)
@@ -167,14 +212,38 @@ def json_handler(obj: Dict, ctx: HydrationContext):
         return RemoveValue()
 
 
+@handler("jinja")
+def jinja_handler(obj: dict, ctx: HydrationContext):
+    if "template" in obj:
+        if isinstance(obj["template"], dict):
+            dehydrated_jinja = _hydrate(obj["template"], ctx)
+        else:
+            dehydrated_jinja = obj["template"]
+
+        try:
+            validate_user_template(dehydrated_jinja)
+        except (jinja2.exceptions.TemplateSyntaxError, TemplateSecurityError) as exc:
+            return InvalidJinja(detail=str(exc))
+
+        if ctx.render_jinja:
+            return render_user_template_sync(dehydrated_jinja, ctx.jinja_context)
+        else:
+            return ValidJinja(template=dehydrated_jinja)
+    else:
+        return TemplateNotFound()
+
+
 @handler("workspace_variable")
-def workspace_variable_handler(obj: Dict, ctx: HydrationContext):
+def workspace_variable_handler(obj: dict, ctx: HydrationContext):
     if "variable_name" in obj:
         if isinstance(obj["variable_name"], dict):
             dehydrated_variable = _hydrate(obj["variable_name"], ctx)
         else:
             dehydrated_variable = obj["variable_name"]
 
+        if not ctx.render_workspace_variables:
+            return WorkspaceVariable(variable_name=obj["variable_name"])
+
         if dehydrated_variable in ctx.workspace_variables:
             return ctx.workspace_variables[dehydrated_variable]
         else:
@@ -191,7 +260,7 @@ def workspace_variable_handler(obj: Dict, ctx: HydrationContext):
         return RemoveValue()
 
 
-def hydrate(obj: Dict, ctx: Optional[HydrationContext] = None):
+def hydrate(obj: dict, ctx: Optional[HydrationContext] = None):
     res = _hydrate(obj, ctx)
 
     if _remove_value(res):
@@ -200,7 +269,7 @@ def hydrate(obj: Dict, ctx: Optional[HydrationContext] = None):
     return res
 
 
-def _hydrate(obj, ctx: Optional[HydrationContext] = None):
+def _hydrate(obj, ctx: Optional[HydrationContext] = None) -> Any:
     if ctx is None:
         ctx = HydrationContext()
 

prefect/utilities/schema_tools/validation.py

@@ -232,7 +232,7 @@ def preprocess_schema(schema):
         process_properties(schema["properties"], required_fields)
 
     if "definitions" in schema:  # Also process definitions for reused models
-        for definition in schema["definitions"].values():
+        for definition in (schema["definitions"] or {}).values():
             if "properties" in definition:
                 required_fields = definition.get("required", [])
                 process_properties(definition["properties"], required_fields)

prefect/variables.py

@@ -30,11 +30,11 @@ class Variable(VariableRequest):
         """
         Sets a new variable. If one exists with the same name, user must pass `overwrite=True`
         ```
-            from prefect import variables
+            from prefect.variables import Variable
 
             @flow
             def my_flow():
-                var = variables.Variable.set(name="my_var",value="test_value", tags=["hi", "there"], overwrite=True)
+                var = Variable.set(name="my_var",value="test_value", tags=["hi", "there"], overwrite=True)
         ```
         or
         ```
@@ -69,11 +69,11 @@ class Variable(VariableRequest):
         """
         Get a variable by name. If doesn't exist return the default.
         ```
-            from prefect import variables
+            from prefect.variables import Variable
 
             @flow
             def my_flow():
-                var = variables.Variable.get("my_var")
+                var = Variable.get("my_var")
         ```
         or
         ```

{prefect_client-2.17.1.dist-info → prefect_client-2.18.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.17.1
+Version: 2.18.1
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.