prefect-client 3.0.0rc19__py3-none-any.whl → 3.0.1__py3-none-any.whl

prefect/settings.py

@@ -425,13 +425,20 @@ def default_database_connection_url(settings: "Settings", value: Optional[str]):
                 f"Missing required database connection settings: {', '.join(missing)}"
             )
 
-        host = PREFECT_API_DATABASE_HOST.value_from(settings)
-        port = PREFECT_API_DATABASE_PORT.value_from(settings) or 5432
-        user = PREFECT_API_DATABASE_USER.value_from(settings)
-        name = PREFECT_API_DATABASE_NAME.value_from(settings)
-        password = PREFECT_API_DATABASE_PASSWORD.value_from(settings)
-
-        return f"{driver}://{user}:{password}@{host}:{port}/{name}"
+        # We only need SQLAlchemy here if we're parsing a remote database connection
+        # string.  Import it here so that we don't require the prefect-client package
+        # to have SQLAlchemy installed.
+        from sqlalchemy import URL
+
+        return URL(
+            drivername=driver,
+            host=PREFECT_API_DATABASE_HOST.value_from(settings),
+            port=PREFECT_API_DATABASE_PORT.value_from(settings) or 5432,
+            username=PREFECT_API_DATABASE_USER.value_from(settings),
+            password=PREFECT_API_DATABASE_PASSWORD.value_from(settings),
+            database=PREFECT_API_DATABASE_NAME.value_from(settings),
+            query=[],
+        ).render_as_string(hide_password=False)
 
     elif driver == "sqlite+aiosqlite":
         path = PREFECT_API_DATABASE_NAME.value_from(settings)
@@ -2184,13 +2191,20 @@ def _write_profiles_to(path: Path, profiles: ProfilesCollection) -> None:
     return path.write_text(toml.dumps(profiles.to_dict()))
 
 
-def load_profiles() -> ProfilesCollection:
+def load_profiles(include_defaults: bool = True) -> ProfilesCollection:
     """
-    Load all profiles from the default and current profile paths.
+    Load profiles from the current profile path. Optionally include profiles from the
+    default profile path.
     """
-    profiles = _read_profiles_from(DEFAULT_PROFILES_PATH)
+    default_profiles = _read_profiles_from(DEFAULT_PROFILES_PATH)
+
+    if not include_defaults:
+        if not PREFECT_PROFILES_PATH.value().exists():
+            return ProfilesCollection([])
+        return _read_profiles_from(PREFECT_PROFILES_PATH.value())
 
     user_profiles_path = PREFECT_PROFILES_PATH.value()
+    profiles = default_profiles
     if user_profiles_path.exists():
         user_profiles = _read_profiles_from(user_profiles_path)
 

prefect/states.py

@@ -18,13 +18,14 @@ from prefect.exceptions import (
     CancelledRun,
     CrashedRun,
     FailedRun,
+    MissingContextError,
     MissingResult,
     PausedRun,
     TerminationSignal,
     UnfinishedRun,
 )
-from prefect.logging.loggers import get_logger
-from prefect.results import BaseResult, R, ResultFactory
+from prefect.logging.loggers import get_logger, get_run_logger
+from prefect.results import BaseResult, R, ResultStore
 from prefect.settings import PREFECT_ASYNC_FETCH_STATE_RESULT
 from prefect.utilities.annotations import BaseAnnotation
 from prefect.utilities.asyncutils import in_async_main_thread, sync_compatible
@@ -166,7 +167,7 @@ def format_exception(exc: BaseException, tb: TracebackType = None) -> str:
 
 async def exception_to_crashed_state(
     exc: BaseException,
-    result_factory: Optional[ResultFactory] = None,
+    result_store: Optional[ResultStore] = None,
 ) -> State:
     """
     Takes an exception that occurs _outside_ of user code and converts it to a
@@ -205,8 +206,8 @@ async def exception_to_crashed_state(
             f" {format_exception(exc)}"
         )
 
-    if result_factory:
-        data = await result_factory.create_result(exc)
+    if result_store:
+        data = await result_store.create_result(exc)
     else:
         # Attach the exception for local usage, will not be available when retrieved
         # from the API
@@ -217,12 +218,18 @@ async def exception_to_crashed_state(
 
 async def exception_to_failed_state(
     exc: Optional[BaseException] = None,
-    result_factory: Optional[ResultFactory] = None,
+    result_store: Optional[ResultStore] = None,
+    write_result: bool = False,
     **kwargs,
 ) -> State:
     """
     Convenience function for creating `Failed` states from exceptions
     """
+    try:
+        local_logger = get_run_logger()
+    except MissingContextError:
+        local_logger = logger
+
     if not exc:
         _, exc, _ = sys.exc_info()
         if exc is None:
@@ -232,8 +239,16 @@ async def exception_to_failed_state(
     else:
         pass
 
-    if result_factory:
-        data = await result_factory.create_result(exc)
+    if result_store:
+        data = await result_store.create_result(exc)
+        if write_result:
+            try:
+                await data.write()
+            except Exception as exc:
+                local_logger.warning(
+                    "Failed to write result: %s Execution will continue, but the result has not been written",
+                    exc,
+                )
     else:
         # Attach the exception for local usage, will not be available when retrieved
         # from the API
@@ -255,10 +270,10 @@ async def exception_to_failed_state(
 
 async def return_value_to_state(
     retval: R,
-    result_factory: ResultFactory,
+    result_store: ResultStore,
     key: Optional[str] = None,
     expiration: Optional[datetime.datetime] = None,
-    defer_persistence: bool = False,
+    write_result: bool = False,
 ) -> State[R]:
     """
     Given a return value from a user's function, create a `State` the run should
@@ -280,6 +295,10 @@ async def return_value_to_state(
     Callers should resolve all futures into states before passing return values to this
     function.
     """
+    try:
+        local_logger = get_run_logger()
+    except MissingContextError:
+        local_logger = logger
 
     if (
         isinstance(retval, State)
@@ -288,16 +307,23 @@ async def return_value_to_state(
         and not retval.state_details.task_run_id
     ):
         state = retval
-        # Unless the user has already constructed a result explicitly, use the factory
+        # Unless the user has already constructed a result explicitly, use the store
         # to update the data to the correct type
         if not isinstance(state.data, BaseResult):
-            state.data = await result_factory.create_result(
+            result = await result_store.create_result(
                 state.data,
                 key=key,
                 expiration=expiration,
-                defer_persistence=defer_persistence,
             )
-
+            if write_result:
+                try:
+                    await result.write()
+                except Exception as exc:
+                    local_logger.warning(
+                        "Encountered an error while persisting result: %s Execution will continue, but the result has not been persisted",
+                        exc,
+                    )
+            state.data = result
         return state
 
     # Determine a new state from the aggregate of contained states
@@ -333,15 +359,23 @@ async def return_value_to_state(
         # TODO: We may actually want to set the data to a `StateGroup` object and just
         #       allow it to be unpacked into a tuple and such so users can interact with
         #       it
+        result = await result_store.create_result(
+            retval,
+            key=key,
+            expiration=expiration,
+        )
+        if write_result:
+            try:
+                await result.write()
+            except Exception as exc:
+                local_logger.warning(
+                    "Encountered an error while persisting result: %s Execution will continue, but the result has not been persisted",
+                    exc,
+                )
         return State(
             type=new_state_type,
             message=message,
-            data=await result_factory.create_result(
-                retval,
-                key=key,
-                expiration=expiration,
-                defer_persistence=defer_persistence,
-            ),
+            data=result,
         )
 
     # Generators aren't portable, implicitly convert them to a list.
@@ -354,14 +388,20 @@ async def return_value_to_state(
     if isinstance(data, BaseResult):
         return Completed(data=data)
     else:
-        return Completed(
-            data=await result_factory.create_result(
-                data,
-                key=key,
-                expiration=expiration,
-                defer_persistence=defer_persistence,
-            )
+        result = await result_store.create_result(
+            data,
+            key=key,
+            expiration=expiration,
         )
+        if write_result:
+            try:
+                await result.write()
+            except Exception as exc:
+                local_logger.warning(
+                    "Encountered an error while persisting result: %s Execution will continue, but the result has not been persisted",
+                    exc,
+                )
+        return Completed(data=result)
 
 
 @sync_compatible
@@ -684,6 +724,21 @@ def AwaitingRetry(
     )
 
 
+def AwaitingConcurrencySlot(
+    cls: Type[State[R]] = State,
+    scheduled_time: Optional[datetime.datetime] = None,
+    **kwargs: Any,
+) -> State[R]:
+    """Convenience function for creating `AwaitingConcurrencySlot` states.
+
+    Returns:
+        State: a AwaitingConcurrencySlot state
+    """
+    return Scheduled(
+        cls=cls, scheduled_time=scheduled_time, name="AwaitingConcurrencySlot", **kwargs
+    )
+
+
 def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Retrying` states.
 

prefect/task_engine.py

@@ -5,6 +5,7 @@ import time
 from asyncio import CancelledError
 from contextlib import ExitStack, asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
+from functools import partial
 from textwrap import dedent
 from typing import (
     Any,
@@ -54,8 +55,12 @@ from prefect.exceptions import (
 )
 from prefect.futures import PrefectFuture
 from prefect.logging.loggers import get_logger, patch_print, task_run_logger
-from prefect.records.result_store import ResultFactoryStore
-from prefect.results import BaseResult, ResultFactory, _format_user_supplied_storage_key
+from prefect.records.result_store import ResultRecordStore
+from prefect.results import (
+    BaseResult,
+    _format_user_supplied_storage_key,
+    get_current_result_store,
+)
 from prefect.settings import (
     PREFECT_DEBUG_MODE,
     PREFECT_TASKS_REFRESH_CACHE,
@@ -449,9 +454,9 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             return self._raised
 
     def handle_success(self, result: R, transaction: Transaction) -> R:
-        result_factory = getattr(TaskRunContext.get(), "result_factory", None)
-        if result_factory is None:
-            raise ValueError("Result factory is not set")
+        result_store = getattr(TaskRunContext.get(), "result_store", None)
+        if result_store is None:
+            raise ValueError("Result store is not set")
 
         if self.task.cache_expiration is not None:
             expiration = pendulum.now("utc") + self.task.cache_expiration
@@ -461,16 +466,19 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         terminal_state = run_coro_as_sync(
             return_value_to_state(
                 result,
-                result_factory=result_factory,
+                result_store=result_store,
                 key=transaction.key,
                 expiration=expiration,
-                # defer persistence to transaction commit
-                defer_persistence=True,
             )
         )
+
+        # Avoid logging when running this rollback hook since it is not user-defined
+        handle_rollback = partial(self.handle_rollback)
+        handle_rollback.log_on_run = False
+
         transaction.stage(
             terminal_state.data,
-            on_rollback_hooks=[self.handle_rollback] + self.task.on_rollback_hooks,
+            on_rollback_hooks=[handle_rollback] + self.task.on_rollback_hooks,
             on_commit_hooks=self.task.on_commit_hooks,
         )
         if transaction.is_committed():
@@ -535,7 +543,8 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                 exception_to_failed_state(
                     exc,
                     message="Task run encountered an exception",
-                    result_factory=getattr(context, "result_factory", None),
+                    result_store=getattr(context, "result_store", None),
+                    write_result=True,
                 )
             )
             self.record_terminal_state_timing(state)
@@ -586,7 +595,9 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                     log_prints=log_prints,
                     task_run=self.task_run,
                     parameters=self.parameters,
-                    result_factory=run_coro_as_sync(ResultFactory.from_task(self.task)),  # type: ignore
+                    result_store=get_current_result_store().update_for_task(
+                        self.task, _sync=True
+                    ),
                     client=client,
                 )
             )
@@ -705,17 +716,22 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     @contextmanager
     def transaction_context(self) -> Generator[Transaction, None, None]:
-        result_factory = getattr(TaskRunContext.get(), "result_factory", None)
-
         # refresh cache setting is now repurposes as overwrite transaction record
         overwrite = (
             self.task.refresh_cache
             if self.task.refresh_cache is not None
             else PREFECT_TASKS_REFRESH_CACHE.value()
         )
+
+        result_store = getattr(TaskRunContext.get(), "result_store", None)
+        if result_store and result_store.persist_result:
+            store = ResultRecordStore(result_store=result_store)
+        else:
+            store = None
+
         with transaction(
             key=self.compute_transaction_key(),
-            store=ResultFactoryStore(result_factory=result_factory),
+            store=store,
             overwrite=overwrite,
             logger=self.logger,
         ) as txn:
@@ -950,9 +966,9 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             return self._raised
 
     async def handle_success(self, result: R, transaction: Transaction) -> R:
-        result_factory = getattr(TaskRunContext.get(), "result_factory", None)
-        if result_factory is None:
-            raise ValueError("Result factory is not set")
+        result_store = getattr(TaskRunContext.get(), "result_store", None)
+        if result_store is None:
+            raise ValueError("Result store is not set")
 
         if self.task.cache_expiration is not None:
             expiration = pendulum.now("utc") + self.task.cache_expiration
@@ -961,15 +977,18 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
         terminal_state = await return_value_to_state(
             result,
-            result_factory=result_factory,
+            result_store=result_store,
             key=transaction.key,
             expiration=expiration,
-            # defer persistence to transaction commit
-            defer_persistence=True,
         )
+
+        # Avoid logging when running this rollback hook since it is not user-defined
+        handle_rollback = partial(self.handle_rollback)
+        handle_rollback.log_on_run = False
+
         transaction.stage(
             terminal_state.data,
-            on_rollback_hooks=[self.handle_rollback] + self.task.on_rollback_hooks,
+            on_rollback_hooks=[handle_rollback] + self.task.on_rollback_hooks,
             on_commit_hooks=self.task.on_commit_hooks,
         )
         if transaction.is_committed():
@@ -1033,7 +1052,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             state = await exception_to_failed_state(
                 exc,
                 message="Task run encountered an exception",
-                result_factory=getattr(context, "result_factory", None),
+                result_store=getattr(context, "result_store", None),
             )
             self.record_terminal_state_timing(state)
             await self.set_state(state)
@@ -1083,7 +1102,9 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                     log_prints=log_prints,
                     task_run=self.task_run,
                     parameters=self.parameters,
-                    result_factory=await ResultFactory.from_task(self.task),  # type: ignore
+                    result_store=await get_current_result_store().update_for_task(
+                        self.task, _sync=False
+                    ),
                     client=client,
                 )
             )
@@ -1199,17 +1220,21 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     @asynccontextmanager
     async def transaction_context(self) -> AsyncGenerator[Transaction, None]:
-        result_factory = getattr(TaskRunContext.get(), "result_factory", None)
-
         # refresh cache setting is now repurposes as overwrite transaction record
         overwrite = (
             self.task.refresh_cache
             if self.task.refresh_cache is not None
             else PREFECT_TASKS_REFRESH_CACHE.value()
         )
+        result_store = getattr(TaskRunContext.get(), "result_store", None)
+        if result_store and result_store.persist_result:
+            store = ResultRecordStore(result_store=result_store)
+        else:
+            store = None
+
         with transaction(
             key=self.compute_transaction_key(),
-            store=ResultFactoryStore(result_factory=result_factory),
+            store=store,
             overwrite=overwrite,
             logger=self.logger,
         ) as txn:

prefect/task_worker.py

@@ -25,7 +25,7 @@ from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import TaskRun
 from prefect.client.subscriptions import Subscription
 from prefect.logging.loggers import get_logger
-from prefect.results import ResultFactory
+from prefect.results import ResultStore, get_or_create_default_task_scheduling_storage
 from prefect.settings import (
     PREFECT_API_URL,
     PREFECT_TASK_SCHEDULING_DELETE_FAILED_SUBMISSIONS,
@@ -49,7 +49,7 @@ class StopTaskWorker(Exception):
 
 
 def should_try_to_read_parameters(task: Task, task_run: TaskRun) -> bool:
-    """Determines whether a task run should read parameters from the result factory."""
+    """Determines whether a task run should read parameters from the result store."""
     new_enough_state_details = hasattr(
         task_run.state.state_details, "task_parameters_id"
     )
@@ -273,9 +273,11 @@ class TaskWorker:
         if should_try_to_read_parameters(task, task_run):
             parameters_id = task_run.state.state_details.task_parameters_id
             task.persist_result = True
-            factory = await ResultFactory.from_autonomous_task(task)
+            store = await ResultStore(
+                result_storage=await get_or_create_default_task_scheduling_storage()
+            ).update_for_task(task)
             try:
-                run_data = await factory.read_parameters(parameters_id)
+                run_data = await store.read_parameters(parameters_id)
                 parameters = run_data.get("parameters", {})
                 wait_for = run_data.get("wait_for", [])
                 run_context = run_data.get("context", None)

prefect/tasks.py

@@ -50,7 +50,12 @@ from prefect.context import (
 )
 from prefect.futures import PrefectDistributedFuture, PrefectFuture, PrefectFutureList
 from prefect.logging.loggers import get_logger
-from prefect.results import ResultFactory, ResultSerializer, ResultStorage
+from prefect.results import (
+    ResultSerializer,
+    ResultStorage,
+    ResultStore,
+    get_or_create_default_task_scheduling_storage,
+)
 from prefect.settings import (
     PREFECT_TASK_DEFAULT_RETRIES,
     PREFECT_TASK_DEFAULT_RETRY_DELAY_SECONDS,
@@ -201,8 +206,17 @@ def _generate_task_key(fn: Callable[..., Any]) -> str:
 
     qualname = fn.__qualname__.split(".")[-1]
 
+    try:
+        code_obj = getattr(fn, "__code__", None)
+        if code_obj is None:
+            code_obj = fn.__call__.__code__
+    except AttributeError:
+        raise AttributeError(
+            f"{fn} is not a standard Python function object and could not be converted to a task."
+        ) from None
+
     code_hash = (
-        h[:NUM_CHARS_DYNAMIC_KEY] if (h := hash_objects(fn.__code__)) else "unknown"
+        h[:NUM_CHARS_DYNAMIC_KEY] if (h := hash_objects(code_obj)) else "unknown"
     )
 
     return f"{qualname}-{code_hash}"
@@ -752,14 +766,16 @@ class Task(Generic[P, R]):
                 # TODO: Improve use of result storage for parameter storage / reference
                 self.persist_result = True
 
-                factory = await ResultFactory.from_autonomous_task(self, client=client)
+                store = await ResultStore(
+                    result_storage=await get_or_create_default_task_scheduling_storage()
+                ).update_for_task(self)
                 context = serialize_context()
                 data: Dict[str, Any] = {"context": context}
                 if parameters:
                     data["parameters"] = parameters
                 if wait_for:
                     data["wait_for"] = wait_for
-                await factory.store_parameters(parameters_id, data)
+                await store.store_parameters(parameters_id, data)
 
             # collect task inputs
             task_inputs = {
@@ -853,14 +869,16 @@ class Task(Generic[P, R]):
                 # TODO: Improve use of result storage for parameter storage / reference
                 self.persist_result = True
 
-                factory = await ResultFactory.from_autonomous_task(self, client=client)
+                store = await ResultStore(
+                    result_storage=await get_or_create_default_task_scheduling_storage()
+                ).update_for_task(task)
                 context = serialize_context()
                 data: Dict[str, Any] = {"context": context}
                 if parameters:
                     data["parameters"] = parameters
                 if wait_for:
                     data["wait_for"] = wait_for
-                await factory.store_parameters(parameters_id, data)
+                await store.store_parameters(parameters_id, data)
 
             # collect task inputs
             task_inputs = {