prefect 3.0.5.dev2__tar.gz → 3.0.5.dev3__tar.gz

{prefect-3.0.5.dev2/src/prefect.egg-info → prefect-3.0.5.dev3}/PKG-INFO

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

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/setup.cfg

@@ -14,6 +14,7 @@ markers =
 	clear_db: marker to clear the database after test completion
 env = 
 	PREFECT_TEST_MODE = 1
+	PREFECT_UNIT_TEST_MODE = 1
 	PREFECT_LOGGING_SERVER_LEVEL = DEBUG
 asyncio_mode = auto
 asyncio_default_fixture_loop_scope = session

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-03T14:56:09-0400",
+ "date": "2024-10-04T16:36:47-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "f524dc853c832d11e6db728800edb88445b472a9",
- "version": "3.0.5.dev2"
+ "full-revisionid": "f8bcb64b01875e71c6ddaf67f48ded4ae8ae5b5c",
+ "version": "3.0.5.dev3"
 }
 '''  # END VERSION_JSON
 

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/cache_policies.py

@@ -219,7 +219,7 @@ class TaskSource(CachePolicy):
         except TypeError:
             lines = inspect.getsource(task_ctx.task.fn.__class__)
         except OSError as exc:
-            if "could not get source code" in str(exc):
+            if "source code" in str(exc):
                 lines = task_ctx.task.fn.__code__.co_code
             else:
                 raise

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/client/orchestration.py

@@ -1813,7 +1813,35 @@ class PrefectClient:
             response = await self._client.get(f"/deployments/name/{name}")
         except httpx.HTTPStatusError as e:
             if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
+                from prefect.utilities.text import fuzzy_match_string
+
+                deployments = await self.read_deployments()
+                flow_name_map = {
+                    flow.id: flow.name
+                    for flow in await asyncio.gather(
+                        *[
+                            self.read_flow(flow_id)
+                            for flow_id in {d.flow_id for d in deployments}
+                        ]
+                    )
+                }
+
+                raise prefect.exceptions.ObjectNotFound(
+                    http_exc=e,
+                    help_message=(
+                        f"Deployment {name!r} not found; did you mean {fuzzy_match!r}?"
+                        if (
+                            fuzzy_match := fuzzy_match_string(
+                                name,
+                                [
+                                    f"{flow_name_map[d.flow_id]}/{d.name}"
+                                    for d in deployments
+                                ],
+                            )
+                        )
+                        else f"Deployment {name!r} not found. Try `prefect deployment ls` to find available deployments."
+                    ),
+                ) from e
             else:
                 raise
 

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/context.py

@@ -659,12 +659,7 @@ def root_settings_context():
         )
         active_name = "ephemeral"
 
-    with use_profile(
-        profiles[active_name],
-        # Override environment variables if the profile was set by the CLI
-        override_environment_variables=profile_source == "by command line argument",
-    ) as settings_context:
-        return settings_context
+    return SettingsContext(profile=profiles[active_name], settings=Settings())
 
     # Note the above context is exited and the global settings context is used by
     # an override in the `SettingsContext.get` method.

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/exceptions.py

@@ -227,9 +227,19 @@ class ObjectNotFound(PrefectException):
     Raised when the client receives a 404 (not found) from the API.
     """
 
-    def __init__(self, http_exc: Exception, *args, **kwargs):
+    def __init__(
+        self,
+        http_exc: Exception,
+        help_message: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
         self.http_exc = http_exc
-        super().__init__(*args, **kwargs)
+        self.help_message = help_message
+        super().__init__(help_message, *args, **kwargs)
+
+    def __str__(self):
+        return self.help_message or super().__str__()
 
 
 class ObjectAlreadyExists(PrefectException):

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/settings.py

@@ -12,6 +12,7 @@ for settings, at which point we will not need to use the "after" model_validator
 
 import os
 import re
+import sys
 import warnings
 from contextlib import contextmanager
 from datetime import timedelta
@@ -51,7 +52,12 @@ from pydantic import (
     model_serializer,
     model_validator,
 )
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic.fields import FieldInfo
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+)
 from typing_extensions import Literal, Self
 
 from prefect.exceptions import ProfileSettingsValidationError
@@ -60,6 +66,8 @@ from prefect.utilities.collections import visit_collection
 from prefect.utilities.pydantic import handle_secret_render
 
 T = TypeVar("T")
+
+DEFAULT_PREFECT_HOME = Path.home() / ".prefect"
 DEFAULT_PROFILES_PATH = Path(__file__).parent.joinpath("profiles.toml")
 _SECRET_TYPES: Tuple[Type, ...] = (Secret, SecretStr)
 
@@ -87,6 +95,11 @@ def env_var_to_attr_name(env_var: str) -> str:
     return env_var.replace("PREFECT_", "").lower()
 
 
+def is_test_mode() -> bool:
+    """Check if the current process is in test mode."""
+    return bool(os.getenv("PREFECT_TEST_MODE") or os.getenv("PREFECT_UNIT_TEST_MODE"))
+
+
 class Setting:
     """Mimics the old Setting object for compatibility with existing code."""
 
@@ -325,16 +338,122 @@ def default_database_connection_url(settings: "Settings") -> SecretStr:
     return SecretStr(value)
 
 
+###########################################################################
+# Settings Loader
+
+
+def _get_profiles_path() -> Path:
+    """Helper to get the profiles path"""
+
+    if is_test_mode():
+        return DEFAULT_PROFILES_PATH
+    if env_path := os.getenv("PREFECT_PROFILES_PATH"):
+        return Path(env_path)
+    if not (DEFAULT_PREFECT_HOME / "profiles.toml").exists():
+        return DEFAULT_PROFILES_PATH
+    return DEFAULT_PREFECT_HOME / "profiles.toml"
+
+
+class ProfileSettingsTomlLoader(PydanticBaseSettingsSource):
+    """
+    Custom pydantic settings source to load profile settings from a toml file.
+
+    See https://docs.pydantic.dev/latest/concepts/pydantic_settings/#customise-settings-sources
+    """
+
+    def __init__(self, settings_cls: Type[BaseSettings]):
+        super().__init__(settings_cls)
+        self.settings_cls = settings_cls
+        self.profiles_path = _get_profiles_path()
+        self.profile_settings = self._load_profile_settings()
+
+    def _load_profile_settings(self) -> Dict[str, Any]:
+        """Helper method to load the profile settings from the profiles.toml file"""
+
+        all_profile_data = toml.load(self.profiles_path)
+
+        if (
+            sys.argv[0].endswith("/prefect")
+            and len(sys.argv) >= 3
+            and sys.argv[1] == "--profile"
+        ):
+            active_profile = sys.argv[2]
+
+        else:
+            active_profile = os.environ.get("PREFECT_PROFILE") or all_profile_data.get(
+                "active"
+            )
+
+        profiles_data = all_profile_data.get("profiles", {})
+
+        if not active_profile or active_profile not in profiles_data:
+            return {}
+
+        return profiles_data[active_profile]
+
+    def get_field_value(
+        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"PREFECT_{field_name.upper()}")
+        return value, field_name, self.field_is_complex(field)
+
+    def __call__(self) -> Dict[str, Any]:
+        """Called by pydantic to get the settings from our custom source"""
+        if is_test_mode():
+            return {}
+        profile_settings: Dict[str, Any] = {}
+        for field_name, field in self.settings_cls.model_fields.items():
+            value, key, is_complex = self.get_field_value(field, field_name)
+            if value is not None:
+                prepared_value = self.prepare_field_value(
+                    field_name, field, value, is_complex
+                )
+                profile_settings[key] = prepared_value
+        return profile_settings
+
+
 ###########################################################################
 # Settings
 
 
 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,
+        settings_cls: Type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> Tuple[PydanticBaseSettingsSource, ...]:
+        """
+        Define an order for Prefect settings sources.
+
+        The order of the returned callables decides the priority of inputs; first item is the highest priority.
+
+        See https://docs.pydantic.dev/latest/concepts/pydantic_settings/#customise-settings-sources
+        """
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+            ProfileSettingsTomlLoader(settings_cls),
+        )
+
     ###########################################################################
     # CLI
 
@@ -474,7 +593,10 @@ class Settings(BaseSettings):
         Literal["postgresql+asyncpg", "sqlite+aiosqlite"]
     ] = Field(
         default=None,
-        description="The database driver to use when connecting to the database. If not set, the driver will be inferred from the connection URL.",
+        description=(
+            "The database driver to use when connecting to the database. "
+            "If not set, the driver will be inferred from the connection URL."
+        ),
     )
 
     api_database_host: Optional[str] = Field(

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/src/prefect/utilities/text.py

@@ -1,4 +1,5 @@
-from typing import Optional
+import difflib
+from typing import Iterable, Optional
 
 
 def truncated_to(length: int, value: Optional[str]) -> str:
@@ -17,3 +18,14 @@ def truncated_to(length: int, value: Optional[str]) -> str:
     proposed = f"{beginning}...{omitted} additional characters...{end}"
 
     return proposed if len(proposed) < len(value) else value
+
+
+def fuzzy_match_string(
+    word: str,
+    possibilities: Iterable[str],
+    *,
+    n: int = 1,
+    cutoff: float = 0.6,
+) -> Optional[str]:
+    match = difflib.get_close_matches(word, possibilities, n=n, cutoff=cutoff)
+    return match[0] if match else None

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3/src/prefect.egg-info}/PKG-INFO

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

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/tests/test_cache_policies.py

@@ -210,18 +210,17 @@ class TestTaskSourcePolicy:
         task_ctx_a = TaskRunContext.model_construct(task=mock_task_a)
         task_ctx_b = TaskRunContext.model_construct(task=mock_task_b)
 
-        with patch(
-            "inspect.getsource", side_effect=OSError("could not get source code")
-        ):
-            fallback_key_a = policy.compute_key(
-                task_ctx=task_ctx_a, inputs=None, flow_parameters=None
-            )
-            fallback_key_b = policy.compute_key(
-                task_ctx=task_ctx_b, inputs=None, flow_parameters=None
-            )
-
-        assert fallback_key_a and fallback_key_b
-        assert fallback_key_a != fallback_key_b
+        for os_error_msg in {"could not get source code", "source code not available"}:
+            with patch("inspect.getsource", side_effect=OSError(os_error_msg)):
+                fallback_key_a = policy.compute_key(
+                    task_ctx=task_ctx_a, inputs=None, flow_parameters=None
+                )
+                fallback_key_b = policy.compute_key(
+                    task_ctx=task_ctx_b, inputs=None, flow_parameters=None
+                )
+
+            assert fallback_key_a and fallback_key_b
+            assert fallback_key_a != fallback_key_b
 
 
 class TestDefaultPolicy:

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/tests/test_context.py

@@ -26,12 +26,10 @@ from prefect.context import (
 from prefect.exceptions import MissingContextError
 from prefect.results import ResultStore, get_result_store
 from prefect.settings import (
-    DEFAULT_PROFILES_PATH,
     PREFECT_API_KEY,
     PREFECT_API_URL,
     PREFECT_HOME,
     PREFECT_PROFILES_PATH,
-    PREFECT_SERVER_ALLOW_EPHEMERAL_MODE,
     Profile,
     ProfilesCollection,
     save_profiles,
@@ -294,20 +292,10 @@ class TestSettingsContext:
         save_profiles(ProfilesCollection(profiles=[profile]))
         return profile
 
-    def test_root_settings_context_default(self, monkeypatch):
-        use_profile = MagicMock()
-        monkeypatch.setattr("prefect.context.use_profile", use_profile)
+    def test_root_settings_context_default(self):
         result = root_settings_context()
-        use_profile.assert_called_once_with(
-            Profile(
-                name="ephemeral",
-                settings={PREFECT_SERVER_ALLOW_EPHEMERAL_MODE: "true"},
-                source=DEFAULT_PROFILES_PATH,
-            ),
-            override_environment_variables=False,
-        )
-        use_profile().__enter__.assert_called_once()
         assert result is not None
+        assert isinstance(result, SettingsContext)
 
     @pytest.mark.parametrize(
         "cli_command",
@@ -321,19 +309,8 @@ class TestSettingsContext:
     def test_root_settings_context_default_if_cli_args_do_not_match_format(
         self, monkeypatch, cli_command
     ):
-        use_profile = MagicMock()
-        monkeypatch.setattr("prefect.context.use_profile", use_profile)
         monkeypatch.setattr("sys.argv", cli_command)
         result = root_settings_context()
-        use_profile.assert_called_once_with(
-            Profile(
-                name="ephemeral",
-                settings={PREFECT_SERVER_ALLOW_EPHEMERAL_MODE: "true"},
-                source=DEFAULT_PROFILES_PATH,
-            ),
-            override_environment_variables=False,
-        )
-        use_profile().__enter__.assert_called_once_with()
         assert result is not None
 
     def test_root_settings_context_respects_cli(self, monkeypatch, foo_profile):
@@ -341,34 +318,22 @@ class TestSettingsContext:
         monkeypatch.setattr("prefect.context.use_profile", use_profile)
         monkeypatch.setattr("sys.argv", ["/prefect", "--profile", "foo"])
         result = root_settings_context()
-        use_profile.assert_called_once_with(
-            foo_profile,
-            override_environment_variables=True,
-        )
-        use_profile().__enter__.assert_called_once_with()
         assert result is not None
 
     def test_root_settings_context_respects_environment_variable(
-        self, monkeypatch, foo_profile
+        self, temporary_profiles_path, monkeypatch
     ):
-        use_profile = MagicMock()
-        monkeypatch.setattr("prefect.context.use_profile", use_profile)
-        monkeypatch.setenv("PREFECT_PROFILE", "foo")
-        root_settings_context()
-        use_profile.assert_called_once_with(
-            foo_profile, override_environment_variables=False
-        )
-
-    def test_root_settings_context_missing_cli(self, monkeypatch, capsys):
-        use_profile = MagicMock()
-        monkeypatch.setattr("prefect.context.use_profile", use_profile)
-        monkeypatch.setattr("sys.argv", ["/prefect", "--profile", "bar"])
-        root_settings_context()
-        _, err = capsys.readouterr()
-        assert (
-            "profile 'bar' set by command line argument not found. The default profile"
-            " will be used instead." in err
+        temporary_profiles_path.write_text(
+            textwrap.dedent(
+                """
+                [profiles.foo]
+                PREFECT_API_URL="foo"
+                """
+            )
         )
+        monkeypatch.setenv("PREFECT_PROFILE", "foo")
+        settings_context = root_settings_context()
+        assert settings_context.profile.name == "foo"
 
     def test_root_settings_context_missing_environment_variables(
         self, monkeypatch, capsys

{prefect-3.0.5.dev2 → prefect-3.0.5.dev3}/tests/test_settings.py

@@ -142,26 +142,28 @@ class TestSettingsClass:
 
     def test_settings_to_environment_exclude_unset_empty_if_none_set(self, monkeypatch):
         for key in SETTING_VARIABLES:
-            if not key.startswith("PREFECT_"):
+            if not key.startswith("PREFECT_") or key == "PREFECT_TEST_MODE":
                 continue
             monkeypatch.delenv(key, raising=False)
 
-        assert (
-            Settings().to_environment_variables(
-                exclude_unset=True,
-                exclude={SETTING_VARIABLES[key] for key in DEFAULT_DEPENDENT_SETTINGS},
-            )
-            == {}
-        )
+        assert Settings().to_environment_variables(
+            exclude_unset=True,
+            exclude={SETTING_VARIABLES[key] for key in DEFAULT_DEPENDENT_SETTINGS},
+        ) == {
+            "PREFECT_TEST_MODE": "True",
+        }
 
     def test_settings_to_environment_exclude_unset_only_includes_set(self, monkeypatch):
         for key in SETTING_VARIABLES:
+            if key == "PREFECT_TEST_MODE":
+                continue
             monkeypatch.delenv(key, raising=False)
 
         assert Settings(debug_mode=True, api_key="Hello").to_environment_variables(
             exclude_unset=True,
             exclude={SETTING_VARIABLES[key] for key in DEFAULT_DEPENDENT_SETTINGS},
         ) == {
+            "PREFECT_TEST_MODE": "True",
             "PREFECT_DEBUG_MODE": "True",
             "PREFECT_API_KEY": "Hello",
         }
@@ -620,6 +622,70 @@ class TestTemporarySettings:
         assert PREFECT_TEST_MODE.value() is True
 
 
+class TestSettingsSources:
+    @pytest.fixture
+    def temporary_env_file(self):
+        original_env_content = None
+        env_file = Path(".env")
+
+        if env_file.exists():
+            original_env_content = env_file.read_text()
+
+        def _create_temp_env(content):
+            env_file.write_text(content)
+
+        yield _create_temp_env
+
+        if env_file.exists():
+            env_file.unlink()
+
+        if original_env_content is not None:
+            env_file.write_text(original_env_content)
+
+    def test_env_source(self, temporary_env_file):
+        temporary_env_file("PREFECT_CLIENT_RETRY_EXTRA_CODES=420,500")
+
+        assert Settings().client_retry_extra_codes == {420, 500}
+
+        os.unlink(".env")
+
+        assert Settings().client_retry_extra_codes == set()
+
+    def test_resolution_order(self, temporary_env_file, monkeypatch, tmp_path):
+        profiles_path = tmp_path / "profiles.toml"
+
+        monkeypatch.delenv("PREFECT_TEST_MODE", raising=False)
+        monkeypatch.delenv("PREFECT_UNIT_TEST_MODE", raising=False)
+        monkeypatch.setenv("PREFECT_PROFILES_PATH", str(profiles_path))
+
+        profiles_path.write_text(
+            textwrap.dedent(
+                """
+                active = "foo"
+
+                [profiles.foo]
+                PREFECT_CLIENT_RETRY_EXTRA_CODES = "420,500"
+                """
+            )
+        )
+
+        assert Settings().client_retry_extra_codes == {420, 500}
+
+        temporary_env_file("PREFECT_CLIENT_RETRY_EXTRA_CODES=429,500")
+
+        assert Settings().client_retry_extra_codes == {429, 500}
+
+        os.unlink(".env")
+
+        assert Settings().client_retry_extra_codes == {420, 500}
+
+        monkeypatch.setenv("PREFECT_TEST_MODE", "1")
+        monkeypatch.setenv("PREFECT_UNIT_TEST_MODE", "1")
+        monkeypatch.delenv("PREFECT_PROFILES_PATH", raising=True)
+
+        assert Settings().client_retry_extra_codes == set()
+
+
 class TestLoadProfiles:
     @pytest.fixture(autouse=True)
     def temporary_profiles_path(self, tmp_path):