prefect-client 2.16.7__py3-none-any.whl → 2.16.9__py3-none-any.whl

prefect/_internal/pydantic/utilities/model_dump.py

@@ -0,0 +1,136 @@
+import typing
+import warnings as python_warnings
+
+from pydantic_core import from_json
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+if typing.TYPE_CHECKING:
+    from prefect._internal.pydantic._types import IncEx
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_dump(  # type: ignore[no-redef]
+    model_instance: "BaseModel",
+    *,
+    mode: typing.Union[typing.Literal["json", "python"], str] = "python",
+    include: "IncEx" = None,
+    exclude: "IncEx" = None,
+    by_alias: bool = False,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    round_trip: bool = False,
+    warnings: bool = True,
+) -> typing.Dict[str, typing.Any]:
+    """
+    Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+    Args:
+        mode: The mode in which `to_python` should run.
+            If mode is 'json', the output will only contain JSON serializable types.
+            If mode is 'python', the output may contain non-JSON-serializable Python objects.
+        include: A set of fields to include in the output.
+        exclude: A set of fields to exclude from the output.
+        context: Additional context to pass to the serializer.
+        by_alias: Whether to use the field's alias in the dictionary key if defined.
+        exclude_unset: Whether to exclude fields that have not been explicitly set.
+        exclude_defaults: Whether to exclude fields that are set to their default value.
+        exclude_none: Whether to exclude fields that have a value of `None`.
+        round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+        warnings: Whether to log warnings when invalid fields are encountered.
+        serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
+    Returns:
+        A dictionary representation of the model.
+    """
+    if USE_V2_MODELS:
+        return model_instance.model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+    else:
+        if mode == "json":
+            with python_warnings.catch_warnings():
+                python_warnings.simplefilter("ignore")
+                return from_json(
+                    model_instance.json(
+                        include=include,
+                        exclude=exclude,
+                        by_alias=by_alias,
+                        exclude_unset=exclude_unset,
+                        exclude_defaults=exclude_defaults,
+                        exclude_none=exclude_none,
+                    )
+                )
+
+        return getattr(model_instance, "dict")(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+
+class ModelDumpMixin(BaseModel):
+    def model_dump(
+        self: "Self",
+        *,
+        mode: typing.Union[typing.Literal["json", "python"], str] = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+    ) -> typing.Dict[str, typing.Any]:
+        """
+        Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+        Args:
+            mode: The mode in which `to_python` should run.
+                If mode is 'json', the output will only contain JSON serializable types.
+                If mode is 'python', the output may contain non-JSON-serializable Python objects.
+            include: A set of fields to include in the output.
+            exclude: A set of fields to exclude from the output.
+            context: Additional context to pass to the serializer.
+            by_alias: Whether to use the field's alias in the dictionary key if defined.
+            exclude_unset: Whether to exclude fields that have not been explicitly set.
+            exclude_defaults: Whether to exclude fields that are set to their default value.
+            exclude_none: Whether to exclude fields that have a value of `None`.
+            round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+            warnings: Whether to log warnings when invalid fields are encountered.
+            serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
+        Returns:
+            A dictionary representation of the model.
+        """
+        return model_dump(
+            self,
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+
+
+__all__ = ["model_dump", "ModelDumpMixin"]

prefect/_internal/pydantic/utilities/model_dump_json.py

@@ -0,0 +1,112 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+if typing.TYPE_CHECKING:
+    from prefect._internal.pydantic._types import IncEx
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_dump_json(
+    model_instance: "BaseModel",
+    *,
+    indent: typing.Optional[int] = None,
+    include: "IncEx" = None,
+    exclude: "IncEx" = None,
+    by_alias: bool = False,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    round_trip: bool = False,
+    warnings: bool = True,
+) -> str:
+    """
+    Generate a JSON representation of the model, optionally specifying which fields to include or exclude.
+
+    Args:
+        indent: If provided, the number of spaces to indent the JSON output.
+        include: A list of fields to include in the output.
+        exclude: A list of fields to exclude from the output.
+        by_alias: Whether to use the field's alias in the dictionary key if defined.
+        exclude_unset: Whether to exclude fields that have not been explicitly set.
+        exclude_defaults: Whether to exclude fields that are set to their default value.
+        exclude_none: Whether to exclude fields that have a value of `None`.
+        round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+        warnings: Whether to log warnings when invalid fields are encountered.
+
+    Returns:
+        A JSON representation of the model.
+    """
+    if USE_V2_MODELS:
+        return model_instance.model_dump_json(
+            indent=indent,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+    else:
+        return getattr(model_instance, "json")(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+
+class ModelDumpJsonMixin(BaseModel):
+    def model_dump_json(
+        self: "Self",
+        *,
+        indent: typing.Optional[int] = None,
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+    ) -> str:
+        """
+        Generate a JSON representation of the model, optionally specifying which fields to include or exclude.
+
+        Args:
+            indent: If provided, the number of spaces to indent the JSON output.
+            include: A list of fields to include in the output.
+            exclude: A list of fields to exclude from the output.
+            by_alias: Whether to use the field's alias in the dictionary key if defined.
+            exclude_unset: Whether to exclude fields that have not been explicitly set.
+            exclude_defaults: Whether to exclude fields that are set to their default value.
+            exclude_none: Whether to exclude fields that have a value of `None`.
+            round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+            warnings: Whether to log warnings when invalid fields are encountered.
+
+        Returns:
+            A JSON representation of the model.
+        """
+        return model_dump_json(
+            self,
+            indent=indent,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+
+
+__all__ = ["model_dump_json", "ModelDumpJsonMixin"]

prefect/_internal/pydantic/utilities/model_fields.py

@@ -0,0 +1,50 @@
+import operator
+import typing
+
+from prefect._internal.pydantic._base_model import BaseModel, FieldInfo
+from prefect._internal.pydantic._flags import HAS_PYDANTIC_V2, USE_PYDANTIC_V2
+
+T = typing.TypeVar("T")
+
+if HAS_PYDANTIC_V2 and USE_PYDANTIC_V2:
+
+    class ModelFieldMixin(BaseModel):  # type: ignore [no-redef]
+        pass
+
+else:
+
+    def cast_model_field_to_field_info(model_field: typing.Any) -> FieldInfo:
+        class _FieldInfo(BaseModel):
+            model_field: typing.Any
+
+            @property
+            def annotation(self) -> typing.Any:
+                return getattr(self.model_field, "outer_type_")
+
+            @property
+            def frozen(self) -> bool:
+                return not operator.attrgetter("field_info.allow_mutation")(
+                    self.model_field
+                )
+
+            @property
+            def json_schema_extra(self) -> typing.Dict[str, typing.Any]:
+                return operator.attrgetter("field_info.extra")(self.model_field)
+
+            def __getattr__(self, key: str) -> typing.Any:
+                return getattr(self.model_field, key)
+
+            def __repr__(self) -> str:
+                return repr(self.model_field)
+
+        return typing.cast(FieldInfo, _FieldInfo(model_field=model_field))
+
+    class ModelFieldMixin(BaseModel):
+        model_fields: typing.ClassVar[typing.Dict[str, FieldInfo]]
+
+        def __init_subclass__(cls, **kwargs: typing.Any) -> None:
+            cls.model_fields = {
+                field_name: cast_model_field_to_field_info(field)
+                for field_name, field in getattr(cls, "__fields__", {}).items()
+            }
+            super().__init_subclass__(**kwargs)

prefect/_internal/pydantic/utilities/model_json_schema.py

@@ -0,0 +1,82 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+if typing.TYPE_CHECKING:
+    from prefect._internal.pydantic._types import JsonSchemaMode
+
+from prefect._internal.pydantic._types import DEFAULT_REF_TEMPLATE
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_json_schema(
+    model: typing.Type[T],
+    by_alias: bool = True,
+    ref_template: str = DEFAULT_REF_TEMPLATE,
+    schema_generator: typing.Any = None,
+    mode: "JsonSchemaMode" = "validation",
+) -> typing.Dict[str, typing.Any]:
+    """
+    Generates a JSON schema for a model class.
+
+    Args:
+        by_alias: Whether to use attribute aliases or not.
+        ref_template: The reference template.
+        schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+            `GenerateJsonSchema` with your desired modifications
+        mode: The mode in which to generate the schema.
+
+    Returns:
+        The JSON schema for the given model class.
+    """
+    if USE_V2_MODELS:
+        return model.model_json_schema(
+            by_alias=by_alias,
+            ref_template=ref_template,
+            mode=mode,
+            # We've changed the type of schema_generator of 'schema_generator' to 'typing.Any',
+            # which is will throw an error if its None. So, we've to pass it only if its not None.
+            **{"schema_generator": schema_generator} if schema_generator else {},
+        )
+    else:
+        return getattr(model, "schema")(
+            by_alias=by_alias,
+            ref_template=ref_template,
+        )
+
+
+class ModelJsonSchemaMixin(BaseModel):
+    @classmethod
+    def model_json_schema(
+        cls: typing.Type["Self"],
+        by_alias: bool = True,
+        ref_template: str = DEFAULT_REF_TEMPLATE,
+        schema_generator: typing.Any = None,
+        mode: "JsonSchemaMode" = "validation",
+    ) -> typing.Dict[str, typing.Any]:
+        """
+        Generates a JSON schema for a model class.
+
+        Args:
+            by_alias: Whether to use attribute aliases or not.
+            ref_template: The reference template.
+            schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+                `GenerateJsonSchema` with your desired modifications
+            mode: The mode in which to generate the schema.
+
+        Returns:
+            The JSON schema for the given model class.
+        """
+        return model_json_schema(
+            cls,
+            by_alias=by_alias,
+            ref_template=ref_template,
+            mode=mode,
+        )
+
+
+__all__ = ["model_json_schema", "ModelJsonSchemaMixin"]

prefect/_internal/pydantic/utilities/model_rebuild.py

@@ -0,0 +1,80 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_rebuild(
+    model_instance: typing.Type[T],
+    *,
+    force: bool = False,
+    raise_errors: bool = True,
+    _parent_namespace_depth: int = 2,
+    _types_namespace: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> typing.Optional[bool]:
+    """Try to rebuild the pydantic-core schema for the model.
+
+    This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
+    the initial attempt to build the schema, and automatic rebuilding fails.
+
+    Args:
+        force: Whether to force the rebuilding of the model schema, defaults to `False`.
+        raise_errors: Whether to raise errors, defaults to `True`.
+        _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
+        _types_namespace: The types namespace, defaults to `None`.
+
+    Returns:
+        Returns `None` if the schema is already "complete" and rebuilding was not required.
+        If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
+    """
+
+    if USE_V2_MODELS:
+        return model_instance.model_rebuild(
+            force=force,
+            raise_errors=raise_errors,
+            _parent_namespace_depth=_parent_namespace_depth,
+            _types_namespace=_types_namespace,
+        )
+    else:
+        return getattr(model_instance, "update_forward_refs")()
+
+
+class ModelRebuildMixin(BaseModel):
+    @classmethod
+    def model_rebuild(
+        cls: typing.Type["Self"],
+        *,
+        force: bool = False,
+        raise_errors: bool = True,
+        _parent_namespace_depth: int = 2,
+        _types_namespace: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> typing.Optional[bool]:
+        """Try to rebuild the pydantic-core schema for the model.
+
+        This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
+        the initial attempt to build the schema, and automatic rebuilding fails.
+
+        Args:
+            force: Whether to force the rebuilding of the model schema, defaults to `False`.
+            raise_errors: Whether to raise errors, defaults to `True`.
+            _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
+            _types_namespace: The types namespace, defaults to `None`.
+
+        Returns:
+            Returns `None` if the schema is already "complete" and rebuilding was not required.
+            If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
+        """
+        return model_rebuild(
+            cls,
+            force=force,
+            raise_errors=raise_errors,
+            _parent_namespace_depth=_parent_namespace_depth,
+            _types_namespace=_types_namespace,
+        )
+
+
+__all__ = ["model_rebuild", "ModelRebuildMixin"]

prefect/_internal/pydantic/utilities/model_validate.py

@@ -0,0 +1,75 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_validate(
+    model_instance: typing.Type[T],
+    obj: typing.Any,
+    *,
+    strict: typing.Optional[bool] = False,
+    from_attributes: typing.Optional[bool] = False,
+    context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> T:
+    """
+    Validate a pydantic model instance.
+
+    Args:
+        obj: The object to validate.
+        strict: Whether to enforce types strictly.
+        from_attributes: Whether to extract data from object attributes.
+        context: Additional context to pass to the validator.
+
+    Raises:
+        ValidationError: If the object could not be validated.
+
+    Returns:
+        The validated model instance.
+    """
+    if USE_V2_MODELS:
+        return model_instance.model_validate(
+            obj,
+            strict=strict,
+            from_attributes=from_attributes,
+            context=context,
+        )
+    else:
+        return getattr(model_instance, "validate")(obj)
+
+
+class ModelValidateMixin(BaseModel):
+    @classmethod
+    def model_validate(
+        cls: typing.Type["Self"],
+        obj: typing.Any,
+        *,
+        strict: typing.Optional[bool] = False,
+        from_attributes: typing.Optional[bool] = False,
+        context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> "Self":
+        """
+        Validate a pydantic model instance.
+
+        Args:
+            obj: The object to validate.
+            strict: Whether to enforce types strictly.
+            from_attributes: Whether to extract data from object attributes.
+            context: Additional context to pass to the validator.
+
+        Raises:
+            ValidationError: If the object could not be validated.
+
+        Returns:
+            The validated model instance.
+        """
+        return model_validate(
+            cls, obj, strict=strict, from_attributes=from_attributes, context=context
+        )
+
+
+__all__ = ["model_validate"]

prefect/_internal/pydantic/utilities/model_validate_json.py

@@ -0,0 +1,68 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_validate_json(
+    model: typing.Type[T],
+    json_data: typing.Union[str, bytes, bytearray],
+    *,
+    strict: typing.Optional[bool] = False,
+    context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> T:
+    """
+    Validate the given JSON data against the Pydantic model.
+
+    Args:
+        json_data: The JSON data to validate.
+        strict: Whether to enforce types strictly.
+        context: Extra variables to pass to the validator.
+
+    Returns:
+        The validated Pydantic model.
+
+    Raises:
+        ValueError: If `json_data` is not a JSON string.
+    """
+    if USE_V2_MODELS:
+        return model.model_validate_json(
+            json_data,
+            strict=strict,
+            context=context,
+        )
+    else:
+        return getattr(model, "parse_raw")(json_data)
+
+
+class ModelValidateJsonMixin(BaseModel):
+    @classmethod
+    def model_validate_json(
+        cls: typing.Type["Self"],
+        json_data: typing.Union[str, bytes, bytearray],
+        *,
+        strict: typing.Optional[bool] = False,
+        context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> "Self":
+        """
+        Validate the given JSON data against the Pydantic model.
+
+        Args:
+            json_data: The JSON data to validate.
+            strict: Whether to enforce types strictly.
+            context: Extra variables to pass to the validator.
+
+        Returns:
+            The validated Pydantic model.
+
+        Raises:
+            ValueError: If `json_data` is not a JSON string.
+        """
+        return model_validate_json(cls, json_data, strict=strict, context=context)
+
+
+__all__ = ["model_validate_json", "ModelValidateJsonMixin"]

prefect/_internal/pydantic/utilities/type_adapter.py

@@ -0,0 +1,71 @@
+import typing
+
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T")
+
+if USE_V2_MODELS:
+    from pydantic import TypeAdapter  # type: ignore
+
+else:
+    from pydantic import parse_obj_as  # type: ignore
+
+    class TypeAdapter(typing.Generic[T]):
+        """
+        Type adapters provide a flexible way to perform validation and serialization based on a Python type.
+
+        A `TypeAdapter` instance exposes some of the functionality from `BaseModel` instance methods
+        for types that do not have such methods (such as dataclasses, primitive types, and more).
+
+        **Note:** `TypeAdapter` instances are not types, and cannot be used as type annotations for fields.
+
+        Attributes:
+            core_schema: The core schema for the type.
+            validator (SchemaValidator): The schema validator for the type.
+            serializer: The schema serializer for the type.
+        """
+
+        def __init__(self, type_: typing.Union[T, typing.Type[T]]) -> None:
+            self.type_ = type_
+
+        def validate_python(
+            self,
+            __object: typing.Any,
+            /,
+            *,
+            strict: typing.Optional[bool] = None,
+            from_attributes: typing.Optional[bool] = None,
+            context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        ) -> T:
+            return parse_obj_as(self.type_, __object)  # type: ignore
+
+
+def validate_python(
+    type_: typing.Union[T, typing.Type[T]],
+    __object: typing.Any,
+    /,
+    *,
+    strict: typing.Optional[bool] = None,
+    from_attributes: typing.Optional[bool] = None,
+    context: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> T:
+    """Validate a Python object against the model.
+
+    Args:
+        type_: The type to validate against.
+        __object: The Python object to validate against the model.
+        strict: Whether to strictly check types.
+        from_attributes: Whether to extract data from object attributes.
+        context: Additional context to pass to the validator.
+
+    !!! note
+        When using `TypeAdapter` with a Pydantic `dataclass`, the use of the `from_attributes`
+        argument is not supported.
+
+    Returns:
+        The validated object.
+    """
+    return TypeAdapter(type_).validate_python(__object)
+
+
+__all__ = ["TypeAdapter", "validate_python"]