prefect-client 3.0.7__tar.gz → 3.0.8__tar.gz

{prefect-client-3.0.7/src/prefect_client.egg-info → prefect-client-3.0.8}/PKG-INFO

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

{prefect-client-3.0.7 → prefect-client-3.0.8}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-09T17:55:58-0500",
+ "date": "2024-10-10T10:17:25-0500",
  "dirty": true,
  "error": null,
- "full-revisionid": "8fee9e1ef3f2b4f71adcf080bf9cb36db79c5f5a",
- "version": "3.0.7"
+ "full-revisionid": "0894bad49e256657cab8208205623c4c7b75ad1f",
+ "version": "3.0.8"
 }
 '''  # END VERSION_JSON
 

{prefect-client-3.0.7 → prefect-client-3.0.8}/src/prefect/settings.py

@@ -10,7 +10,6 @@ After https://github.com/pydantic/pydantic/issues/9789 is resolved, we will be a
 for settings, at which point we will not need to use the "after" model_validator.
 """
 
-import inspect
 import os
 import re
 import sys
@@ -63,11 +62,7 @@ from typing_extensions import Literal, Self
 
 from prefect.exceptions import ProfileSettingsValidationError
 from prefect.types import ClientRetryExtraCodes, LogLevel
-from prefect.utilities.collections import (
-    deep_merge_dicts,
-    set_in_dict,
-    visit_collection,
-)
+from prefect.utilities.collections import visit_collection
 from prefect.utilities.pydantic import handle_secret_render
 
 T = TypeVar("T")
@@ -77,12 +72,10 @@ DEFAULT_PROFILES_PATH = Path(__file__).parent.joinpath("profiles.toml")
 _SECRET_TYPES: Tuple[Type, ...] = (Secret, SecretStr)
 
 
-def env_var_to_accessor(env_var: str) -> str:
+def env_var_to_attr_name(env_var: str) -> str:
     """
-    Convert an environment variable name to a settings accessor.
+    Convert an environment variable name to an attribute name.
     """
-    if SETTING_VARIABLES.get(env_var) is not None:
-        return SETTING_VARIABLES[env_var].accessor
     return env_var.replace("PREFECT_", "").lower()
 
 
@@ -94,21 +87,19 @@ def is_test_mode() -> bool:
 class Setting:
     """Mimics the old Setting object for compatibility with existing code."""
 
-    def __init__(
-        self, name: str, default: Any, type_: Any, accessor: Optional[str] = None
-    ):
+    def __init__(self, name: str, default: Any, type_: Any):
         self._name = name
         self._default = default
         self._type = type_
-        if accessor is None:
-            self.accessor = env_var_to_accessor(name)
-        else:
-            self.accessor = accessor
 
     @property
     def name(self):
         return self._name
 
+    @property
+    def field_name(self):
+        return env_var_to_attr_name(self.name)
+
     @property
     def is_secret(self):
         if self._type in _SECRET_TYPES:
@@ -128,19 +119,13 @@ class Setting:
             else:
                 return None
 
-        path = self.accessor.split(".")
-        current_value = get_current_settings()
-        for key in path:
-            current_value = getattr(current_value, key, None)
+        current_value = getattr(get_current_settings(), self.field_name)
         if isinstance(current_value, _SECRET_TYPES):
             return current_value.get_secret_value()
         return current_value
 
     def value_from(self: Self, settings: "Settings") -> Any:
-        path = self.accessor.split(".")
-        current_value = settings
-        for key in path:
-            current_value = getattr(current_value, key, None)
+        current_value = getattr(settings, self.field_name)
         if isinstance(current_value, _SECRET_TYPES):
             return current_value.get_secret_value()
         return current_value
@@ -172,7 +157,7 @@ def default_ui_url(settings: "Settings") -> Optional[str]:
         return value
 
     # Otherwise, infer a value from the API URL
-    ui_url = api_url = settings.api.url
+    ui_url = api_url = settings.api_url
 
     if not api_url:
         return None
@@ -258,7 +243,7 @@ def warn_on_misconfigured_api_url(values):
     """
     Validator for settings warning if the API URL is misconfigured.
     """
-    api_url = values.get("api", {}).get("url")
+    api_url = values["api_url"]
     if api_url is not None:
         misconfigured_mappings = {
             "app.prefect.cloud": (
@@ -403,9 +388,7 @@ class ProfileSettingsTomlLoader(PydanticBaseSettingsSource):
         self, field: FieldInfo, field_name: str
     ) -> Tuple[Any, str, bool]:
         """Concrete implementation to get the field value from the profile settings"""
-        value = self.profile_settings.get(
-            f"{self.config.get('env_prefix','')}{field_name.upper()}"
-        )
+        value = self.profile_settings.get(f"PREFECT_{field_name.upper()}")
         return value, field_name, self.field_is_complex(field)
 
     def __call__(self) -> Dict[str, Any]:
@@ -425,7 +408,21 @@ class ProfileSettingsTomlLoader(PydanticBaseSettingsSource):
 
 ###########################################################################
 # Settings
-class PrefectBaseSettings(BaseSettings):
+
+
+class Settings(BaseSettings):
+    """
+    Settings for Prefect using Pydantic settings.
+
+    See https://docs.pydantic.dev/latest/concepts/pydantic_settings
+    """
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_prefix="PREFECT_",
+        extra="ignore",
+    )
+
     @classmethod
     def settings_customise_sources(
         cls,
@@ -450,104 +447,6 @@ class PrefectBaseSettings(BaseSettings):
             ProfileSettingsTomlLoader(settings_cls),
         )
 
-    @classmethod
-    def valid_setting_names(cls) -> Set[str]:
-        """
-        A set of valid setting names, e.g. "PREFECT_API_URL" or "PREFECT_API_KEY".
-        """
-        settings_fields = set()
-        for field_name, field in cls.model_fields.items():
-            if inspect.isclass(field.annotation) and issubclass(
-                field.annotation, PrefectBaseSettings
-            ):
-                settings_fields.update(field.annotation.valid_setting_names())
-            else:
-                settings_fields.add(
-                    f"{cls.model_config.get('env_prefix')}{field_name.upper()}"
-                )
-        return settings_fields
-
-    def to_environment_variables(
-        self,
-        exclude_unset: bool = False,
-        include_secrets: bool = True,
-    ) -> Dict[str, str]:
-        """Convert the settings object to a dictionary of environment variables."""
-
-        env: Dict[str, Any] = self.model_dump(
-            exclude_unset=exclude_unset,
-            mode="json",
-            context={"include_secrets": include_secrets},
-        )
-        env_variables = {}
-        for key, value in env.items():
-            if isinstance(value, dict) and isinstance(
-                child_settings := getattr(self, key), PrefectBaseSettings
-            ):
-                child_env = child_settings.to_environment_variables(
-                    exclude_unset=exclude_unset,
-                    include_secrets=include_secrets,
-                )
-                env_variables.update(child_env)
-            elif value is not None:
-                env_variables[
-                    f"{self.model_config.get('env_prefix')}{key.upper()}"
-                ] = str(value)
-        return env_variables
-
-
-class APISettings(PrefectBaseSettings):
-    """
-    Settings for interacting with the Prefect API
-    """
-
-    model_config = SettingsConfigDict(
-        env_prefix="PREFECT_API_", env_file=".env", extra="ignore"
-    )
-    url: Optional[str] = Field(
-        default=None,
-        description="The URL of the Prefect API. If not set, the client will attempt to infer it.",
-    )
-    key: Optional[SecretStr] = Field(
-        default=None,
-        description="The API key used for authentication with the Prefect API. Should be kept secret.",
-    )
-    tls_insecure_skip_verify: bool = Field(
-        default=False,
-        description="If `True`, disables SSL checking to allow insecure requests. This is recommended only during development, e.g. when using self-signed certificates.",
-    )
-    ssl_cert_file: Optional[str] = Field(
-        default=os.environ.get("SSL_CERT_FILE"),
-        description="This configuration settings option specifies the path to an SSL certificate file.",
-    )
-    enable_http2: bool = Field(
-        default=False,
-        description="If true, enable support for HTTP/2 for communicating with an API. If the API does not support HTTP/2, this will have no effect and connections will be made via HTTP/1.1.",
-    )
-    request_timeout: float = Field(
-        default=60.0,
-        description="The default timeout for requests to the API",
-    )
-    default_limit: int = Field(
-        default=200,
-        description="The default limit applied to queries that can return multiple objects, such as `POST /flow_runs/filter`.",
-    )
-
-
-class Settings(PrefectBaseSettings):
-    """
-    Settings for Prefect using Pydantic settings.
-
-    See https://docs.pydantic.dev/latest/concepts/pydantic_settings
-    """
-
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_prefix="PREFECT_",
-        env_nested_delimiter=None,
-        extra="ignore",
-    )
-
     ###########################################################################
     # CLI
 
@@ -605,9 +504,33 @@ class Settings(PrefectBaseSettings):
     ###########################################################################
     # API settings
 
-    api: APISettings = Field(
-        default_factory=APISettings,
-        description="Settings for interacting with the Prefect API",
+    api_url: Optional[str] = Field(
+        default=None,
+        description="The URL of the Prefect API. If not set, the client will attempt to infer it.",
+    )
+    api_key: Optional[SecretStr] = Field(
+        default=None,
+        description="The API key used for authentication with the Prefect API. Should be kept secret.",
+    )
+
+    api_tls_insecure_skip_verify: bool = Field(
+        default=False,
+        description="If `True`, disables SSL checking to allow insecure requests. This is recommended only during development, e.g. when using self-signed certificates.",
+    )
+
+    api_ssl_cert_file: Optional[str] = Field(
+        default=os.environ.get("SSL_CERT_FILE"),
+        description="This configuration settings option specifies the path to an SSL certificate file.",
+    )
+
+    api_enable_http2: bool = Field(
+        default=False,
+        description="If true, enable support for HTTP/2 for communicating with an API. If the API does not support HTTP/2, this will have no effect and connections will be made via HTTP/1.1.",
+    )
+
+    api_request_timeout: float = Field(
+        default=60.0,
+        description="The default timeout for requests to the API",
     )
 
     api_blocks_register_on_start: bool = Field(
@@ -1506,7 +1429,7 @@ class Settings(PrefectBaseSettings):
 
     def __getattribute__(self, name: str) -> Any:
         if name.startswith("PREFECT_"):
-            field_name = env_var_to_accessor(name)
+            field_name = env_var_to_attr_name(name)
             warnings.warn(
                 f"Accessing `Settings().{name}` is deprecated. Use `Settings().{field_name}` instead.",
                 DeprecationWarning,
@@ -1533,10 +1456,8 @@ class Settings(PrefectBaseSettings):
             self.ui_url = default_ui_url(self)
             self.__pydantic_fields_set__.remove("ui_url")
         if self.ui_api_url is None:
-            if self.api.url:
-                self.ui_api_url = self.api.url
-            if self.api.url:
-                self.ui_api_url = self.api.url
+            if self.api_url:
+                self.ui_api_url = self.api_url
                 self.__pydantic_fields_set__.remove("ui_api_url")
             else:
                 self.ui_api_url = (
@@ -1600,6 +1521,16 @@ class Settings(PrefectBaseSettings):
     ##########################################################################
     # Settings methods
 
+    @classmethod
+    def valid_setting_names(cls) -> Set[str]:
+        """
+        A set of valid setting names, e.g. "PREFECT_API_URL" or "PREFECT_API_KEY".
+        """
+        return set(
+            f"{cls.model_config.get('env_prefix')}{key.upper()}"
+            for key in cls.model_fields.keys()
+        )
+
     def copy_with_update(
         self: Self,
         updates: Optional[Mapping[Setting, Any]] = None,
@@ -1619,26 +1550,14 @@ class Settings(PrefectBaseSettings):
         Returns:
             A new Settings object.
         """
-        restore_defaults_obj = {}
-        for r in restore_defaults or []:
-            set_in_dict(restore_defaults_obj, r.accessor, True)
+        restore_defaults_names = set(r.field_name for r in restore_defaults or [])
         updates = updates or {}
         set_defaults = set_defaults or {}
 
-        set_defaults_obj = {}
-        for setting, value in set_defaults.items():
-            set_in_dict(set_defaults_obj, setting.accessor, value)
-
-        updates_obj = {}
-        for setting, value in updates.items():
-            set_in_dict(updates_obj, setting.accessor, value)
-
         new_settings = self.__class__(
-            **deep_merge_dicts(
-                set_defaults_obj,
-                self.model_dump(exclude_unset=True, exclude=restore_defaults_obj),
-                updates_obj,
-            )
+            **{setting.field_name: value for setting, value in set_defaults.items()}
+            | self.model_dump(exclude_unset=True, exclude=restore_defaults_names)
+            | {setting.field_name: value for setting, value in updates.items()}
         )
         return new_settings
 
@@ -1650,6 +1569,37 @@ class Settings(PrefectBaseSettings):
         env_variables = self.to_environment_variables()
         return str(hash(tuple((key, value) for key, value in env_variables.items())))
 
+    def to_environment_variables(
+        self,
+        include: Optional[Iterable[Setting]] = None,
+        exclude: Optional[Iterable[Setting]] = None,
+        exclude_unset: bool = False,
+        include_secrets: bool = True,
+    ) -> Dict[str, str]:
+        """Convert the settings object to a dictionary of environment variables."""
+        included_names = {s.field_name for s in include} if include else None
+        excluded_names = {s.field_name for s in exclude} if exclude else None
+
+        if exclude_unset:
+            if included_names is None:
+                included_names = set(self.model_dump(exclude_unset=True).keys())
+            else:
+                included_names.intersection_update(
+                    {key for key in self.model_dump(exclude_unset=True)}
+                )
+
+        env: Dict[str, Any] = self.model_dump(
+            include=included_names,
+            exclude=excluded_names,
+            mode="json",
+            context={"include_secrets": include_secrets},
+        )
+        return {
+            f"{self.model_config.get('env_prefix')}{key.upper()}": str(value)
+            for key, value in env.items()
+            if value is not None
+        }
+
     @model_serializer(
         mode="wrap", when_used="always"
     )  # TODO: reconsider `when_used` default for more control
@@ -1659,11 +1609,7 @@ class Settings(PrefectBaseSettings):
         ctx = info.context
         jsonable_self = handler(self)
         if ctx and ctx.get("include_secrets") is True:
-            dump_kwargs = dict(
-                include=info.include,
-                exclude=info.exclude,
-                exclude_unset=info.exclude_unset,
-            )
+            dump_kwargs = dict(include=info.include, exclude=info.exclude)
             jsonable_self.update(
                 {
                     field_name: visit_collection(
@@ -1693,7 +1639,12 @@ def _cast_settings(
     for k, value in settings.items():
         try:
             if isinstance(k, str):
-                setting = SETTING_VARIABLES[k]
+                field = Settings.model_fields[env_var_to_attr_name(k)]
+                setting = Setting(
+                    name=k,
+                    default=field.default,
+                    type_=field.annotation,
+                )
             else:
                 setting = k
             casted_settings[setting] = value
@@ -1788,16 +1739,9 @@ class Profile(BaseModel):
         errors: List[Tuple[Setting, ValidationError]] = []
         for setting, value in self.settings.items():
             try:
-                model_fields = Settings.model_fields
-                annotation = None
-                for section in setting.accessor.split("."):
-                    annotation = model_fields[section].annotation
-                    if inspect.isclass(annotation) and issubclass(
-                        annotation, BaseSettings
-                    ):
-                        model_fields = annotation.model_fields
-
-                TypeAdapter(annotation).validate_python(value)
+                TypeAdapter(
+                    Settings.model_fields[setting.field_name].annotation
+                ).validate_python(value)
             except ValidationError as e:
                 errors.append((setting, e))
         if errors:
@@ -2114,38 +2058,26 @@ def update_current_profile(
 # Allow traditional env var access
 
 
-def _collect_settings_fields(
-    settings_cls: Type[BaseSettings], accessor_prefix: Optional[str] = None
-) -> Dict[str, Setting]:
-    settings_fields: Dict[str, Setting] = {}
-    for field_name, field in settings_cls.model_fields.items():
-        if inspect.isclass(field.annotation) and issubclass(
-            field.annotation, BaseSettings
-        ):
-            accessor = (
-                field_name
-                if accessor_prefix is None
-                else f"{accessor_prefix}.{field_name}"
-            )
-            settings_fields.update(_collect_settings_fields(field.annotation, accessor))
-        else:
-            accessor = (
-                field_name
-                if accessor_prefix is None
-                else f"{accessor_prefix}.{field_name}"
-            )
+class _SettingsDict(dict):
+    """allow either `field_name` or `ENV_VAR_NAME` access
+    ```
+    d = _SettingsDict(Settings)
+    d["api_url"] == d["PREFECT_API_URL"]
+    ```
+    """
+
+    def __init__(self: Self, settings_cls: Type[BaseSettings]):
+        super().__init__()
+        for field_name, field in settings_cls.model_fields.items():
             setting = Setting(
                 name=f"{settings_cls.model_config.get('env_prefix')}{field_name.upper()}",
                 default=field.default,
                 type_=field.annotation,
-                accessor=accessor,
             )
-            settings_fields[setting.name] = setting
-            settings_fields[setting.accessor] = setting
-    return settings_fields
+            self[field_name] = self[setting.name] = setting
 
 
-SETTING_VARIABLES: dict[str, Setting] = _collect_settings_fields(Settings)
+SETTING_VARIABLES: dict[str, Setting] = _SettingsDict(Settings)
 
 
 def __getattr__(name: str) -> Setting:

{prefect-client-3.0.7 → prefect-client-3.0.8}/src/prefect/utilities/collections.py

@@ -513,73 +513,3 @@ def get_from_dict(dct: Dict, keys: Union[str, List[str]], default: Any = None) -
         return dct
     except (TypeError, KeyError, IndexError):
         return default
-
-
-def set_in_dict(dct: Dict, keys: Union[str, List[str]], value: Any):
-    """
-    Sets a value in a nested dictionary using a sequence of keys.
-
-    This function allows to set a value in a deeply nested structure
-    of dictionaries and lists using either a dot-separated string or a list
-    of keys. If a requested key does not exist, the function will create it as
-    a new dictionary.
-
-    Args:
-        dct: The dictionary to set the value in.
-        keys: The sequence of keys to use for access. Can be a
-            dot-separated string or a list of keys.
-        value: The value to set in the dictionary.
-
-    Returns:
-        The modified dictionary with the value set at the specified key path.
-
-    Raises:
-        KeyError: If the key path exists and is not a dictionary.
-    """
-    if isinstance(keys, str):
-        keys = keys.replace("[", ".").replace("]", "").split(".")
-    for k in keys[:-1]:
-        if not isinstance(dct.get(k, {}), dict):
-            raise KeyError(f"Key path exists and contains a non-dict value: {keys}")
-        if k not in dct:
-            dct[k] = {}
-        dct = dct[k]
-    dct[keys[-1]] = value
-
-
-def deep_merge(dct: Dict, merge: Dict):
-    """
-    Recursively merges `merge` into `dct`.
-
-    Args:
-        dct: The dictionary to merge into.
-        merge: The dictionary to merge from.
-
-    Returns:
-        A new dictionary with the merged contents.
-    """
-    result = dct.copy()  # Start with keys and values from `dct`
-    for key, value in merge.items():
-        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
-            # If both values are dictionaries, merge them recursively
-            result[key] = deep_merge(result[key], value)
-        else:
-            # Otherwise, overwrite with the new value
-            result[key] = value
-    return result
-
-
-def deep_merge_dicts(*dicts):
-    """
-    Recursively merges multiple dictionaries.
-
-    Args:
-        dicts: The dictionaries to merge.
-
-    Returns:
-        A new dictionary with the merged contents.
-    """
-    result = {}
-    for dictionary in dicts:
-        result = deep_merge(result, dictionary)
-    return result

{prefect-client-3.0.7 → prefect-client-3.0.8/src/prefect_client.egg-info}/PKG-INFO

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