prefect-client 2.19.8__tar.gz → 2.20.0__tar.gz

{prefect-client-2.19.8/src/prefect_client.egg-info → prefect-client-2.20.0}/PKG-INFO

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

{prefect-client-2.19.8 → prefect-client-2.20.0}/requirements-client.txt

@@ -1,4 +1,4 @@
-anyio >= 3.7.1, < 4.0.0
+anyio >= 4.4.0, < 5.0.0
 asgi-lifespan >= 1.0, < 3.0
 cachetools >= 5.3, < 6.0
 cloudpickle >= 2.0, < 4.0
@@ -6,7 +6,7 @@ coolname >= 1.0.4, < 3.0.0
 croniter >= 1.0.12, < 3.0.0
 fsspec >= 2022.5.0
 graphviz >= 0.20.1
-griffe >= 0.20.0
+griffe >= 0.20.0, <0.48.0
 httpcore >=1.0.5, < 2.0.0
 httpx[http2] >= 0.23, != 0.23.2
 importlib_metadata >= 4.4; python_version < '3.10'

{prefect-client-2.19.8 → prefect-client-2.20.0}/requirements.txt

@@ -2,14 +2,14 @@
 
 aiosqlite >= 0.17.0
 alembic >= 1.7.5, < 2.0.0
-apprise >= 1.1.0, < 2.0.0
+apprise >= 1.8.0, < 2.0.0
 asyncpg >= 0.23
 click >= 8.0, < 8.2
 cryptography >= 36.0.1
 dateparser >= 1.1.1, < 2.0.0
 docker >= 4.0
 graphviz >= 0.20.1
-griffe >= 0.20.0
+griffe >= 0.20.0, <0.48.0
 jinja2 >= 3.0.0, < 4.0.0
 jinja2-humanize-extension >= 0.4.0
 humanize >= 4.9.0
@@ -18,3 +18,4 @@ pytz >= 2021.1, < 2025
 readchar >= 4.0.0, < 5.0.0
 sqlalchemy[asyncio] >= 1.4.22, != 1.4.33, < 3.0.0
 typer >= 0.12.0, != 0.12.2, < 0.13.0
+exceptiongroup >= 1.2.1

{prefect-client-2.19.8 → prefect-client-2.20.0}/setup.cfg

@@ -52,6 +52,7 @@ filterwarnings =
 	ignore::ResourceWarning
 	ignore::pytest.PytestUnraisableExceptionWarning
 	ignore::pluggy.PluggyTeardownRaisedWarning
+	ignore::prefect._internal.compatibility.deprecated.PrefectDeprecationWarning
 
 [mypy]
 plugins = 

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/blocks/notifications.py

@@ -139,12 +139,40 @@ class MicrosoftTeamsWebhook(AppriseNotificationBlock):
     url: SecretStr = Field(
         ...,
         title="Webhook URL",
-        description="The Teams incoming webhook URL used to send notifications.",
+        description="The Microsoft Power Automate (Workflows) URL used to send notifications to Teams.",
         examples=[
-            "https://your-org.webhook.office.com/webhookb2/XXX/IncomingWebhook/YYY/ZZZ"
+            "https://prod-NO.LOCATION.logic.azure.com:443/workflows/WFID/triggers/manual/paths/invoke?sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=SIGNATURE"
         ],
     )
 
+    include_image: bool = Field(
+        default=True,
+        description="Include an image with the notification.",
+    )
+
+    wrap: bool = Field(
+        default=True,
+        description="Wrap the notification text.",
+    )
+
+    def block_initialization(self) -> None:
+        """see https://github.com/caronc/apprise/pull/1172"""
+        from apprise.plugins.workflows import NotifyWorkflows
+
+        if not (
+            parsed_url := NotifyWorkflows.parse_native_url(self.url.get_secret_value())
+        ):
+            raise ValueError("Invalid Microsoft Teams Workflow URL provided.")
+
+        parsed_url.update(
+            {
+                "include_image": self.include_image,
+                "wrap": self.wrap,
+            }
+        )
+
+        self._start_apprise_client(SecretStr(NotifyWorkflows(**parsed_url).url()))
+
 
 class PagerDutyWebHook(AbstractAppriseNotificationBlock):
     """

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/client/schemas/objects.py

@@ -17,6 +17,7 @@ import pendulum
 
 from prefect._internal.compatibility.deprecated import (
     DeprecatedInfraOverridesField,
+    deprecated_class,
 )
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect.types import NonNegativeInteger, PositiveInteger
@@ -917,6 +918,10 @@ class Flow(ObjectBaseModel):
         return raise_on_name_with_banned_characters(v)
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    help="Will be removed in Prefect 3 in favor of prefect.client.schemas.actions.DeploymentScheduleCreate",
+)
 class MinimalDeploymentSchedule(PrefectBaseModel):
     schedule: SCHEDULE_TYPES = Field(
         default=..., description="The schedule for the deployment."

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/deployments/deployments.py

@@ -238,12 +238,17 @@ async def run_deployment(
     return flow_run
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flows:load_flow_from_flow_run",
+)
 @inject_client
 async def load_flow_from_flow_run(
     flow_run: FlowRun,
     client: PrefectClient,
     ignore_storage: bool = False,
     storage_base_path: Optional[str] = None,
+    use_placeholder_flow: bool = True,
 ) -> Flow:
     """
     Load a flow from the location/script provided in a deployment's storage document.
@@ -270,7 +275,7 @@ async def load_flow_from_flow_run(
             f"Importing flow code from module path {deployment.entrypoint}"
         )
         flow = await run_sync_in_worker_thread(
-            load_flow_from_entrypoint, deployment.entrypoint
+            load_flow_from_entrypoint, deployment.entrypoint, use_placeholder_flow
         )
         return flow
 
@@ -314,7 +319,9 @@ async def load_flow_from_flow_run(
             ).absolute()
     run_logger.debug(f"Importing flow code from '{import_path}'")
 
-    flow = await run_sync_in_worker_thread(load_flow_from_entrypoint, str(import_path))
+    flow = await run_sync_in_worker_thread(
+        load_flow_from_entrypoint, str(import_path), use_placeholder_flow
+    )
 
     return flow
 

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/engine.py

@@ -107,13 +107,16 @@ from uuid import UUID, uuid4
 
 import anyio
 import pendulum
-from anyio import start_blocking_portal
+from anyio.from_thread import start_blocking_portal
 from typing_extensions import Literal
 
 import prefect
 import prefect.context
 import prefect.plugins
-from prefect._internal.compatibility.deprecated import deprecated_parameter
+from prefect._internal.compatibility.deprecated import (
+    deprecated_callable,
+    deprecated_parameter,
+)
 from prefect._internal.compatibility.experimental import experimental_parameter
 from prefect._internal.concurrency.api import create_call, from_async, from_sync
 from prefect._internal.concurrency.calls import get_current_call
@@ -208,6 +211,7 @@ from prefect.utilities.engine import (
     _resolve_custom_task_run_name,
     capture_sigterm,
     check_api_reachable,
+    collapse_excgroups,
     collect_task_run_inputs,
     emit_task_run_state_change_event,
     propose_state,
@@ -276,7 +280,7 @@ def enter_flow_run_engine_from_flow_call(
     # the user. Generally, you should enter contexts _within_ the async `begin_run`
     # instead but if you need to enter a context from the main thread you'll need to do
     # it here.
-    contexts = [capture_sigterm()]
+    contexts = [capture_sigterm(), collapse_excgroups()]
 
     if flow.isasync and (
         not is_subflow_run or (is_subflow_run and parent_flow_run_context.flow.isasync)
@@ -321,7 +325,7 @@ def enter_flow_run_engine_from_subprocess(flow_run_id: UUID) -> State:
             flow_run_id,
             user_thread=threading.current_thread(),
         ),
-        contexts=[capture_sigterm()],
+        contexts=[capture_sigterm(), collapse_excgroups()],
     )
 
     APILogHandler.flush()
@@ -417,9 +421,12 @@ async def retrieve_flow_then_begin_flow_run(
 
     try:
         flow = (
-            load_flow_from_entrypoint(entrypoint)
+            # We do not want to use a placeholder flow at runtime
+            load_flow_from_entrypoint(entrypoint, use_placeholder_flow=False)
             if entrypoint
-            else await load_flow_from_flow_run(flow_run, client=client)
+            else await load_flow_from_flow_run(
+                flow_run, client=client, use_placeholder_flow=False
+            )
         )
     except Exception:
         message = (
@@ -975,6 +982,10 @@ async def orchestrate_flow_run(
     return state
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:pause_flow_run",
+)
 @overload
 async def pause_flow_run(
     wait_for_input: None = None,
@@ -987,6 +998,10 @@ async def pause_flow_run(
     ...
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:pause_flow_run",
+)
 @overload
 async def pause_flow_run(
     wait_for_input: Type[T],
@@ -1095,6 +1110,10 @@ async def pause_flow_run(
         )
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:_in_process_pause",
+)
 @inject_client
 async def _in_process_pause(
     timeout: int = 3600,
@@ -1190,6 +1209,10 @@ async def _in_process_pause(
     raise FlowPauseTimeout("Flow run was paused and never resumed.")
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs.pause_flow_run.",
+)
 @inject_client
 async def _out_of_process_pause(
     flow_run_id: UUID,
@@ -1212,6 +1235,10 @@ async def _out_of_process_pause(
         raise RuntimeError(response.details.reason)
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:suspend_flow_run",
+)
 @overload
 async def suspend_flow_run(
     wait_for_input: None = None,
@@ -1343,6 +1370,10 @@ async def suspend_flow_run(
         raise Pause()
 
 
+@deprecated_callable(
+    start_date="Jun 2024",
+    help="Will be moved in Prefect 3 to prefect.flow_runs:resume_flow_run",
+)
 @sync_compatible
 async def resume_flow_run(flow_run_id, run_input: Optional[Dict] = None):
     """
@@ -2218,9 +2249,9 @@ async def report_flow_run_crashes(flow_run: FlowRun, client: PrefectClient, flow
 
     This context _must_ reraise the exception to properly exit the run.
     """
-
     try:
-        yield
+        with collapse_excgroups():
+            yield
     except (Abort, Pause):
         # Do not capture internal signals as crashes
         raise
@@ -2257,7 +2288,8 @@ async def report_task_run_crashes(task_run: TaskRun, client: PrefectClient):
     This context _must_ reraise the exception to properly exit the run.
     """
     try:
-        yield
+        with collapse_excgroups():
+            yield
     except (Abort, Pause):
         # Do not capture internal signals as crashes
         raise

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/flows.py

@@ -1650,6 +1650,7 @@ def load_flow_from_script(path: str, flow_name: str = None) -> Flow:
 
 def load_flow_from_entrypoint(
     entrypoint: str,
+    use_placeholder_flow: bool = True,
 ) -> Flow:
     """
     Extract a flow object from a script at an entrypoint by running all of the code in the file.
@@ -1657,6 +1658,9 @@ def load_flow_from_entrypoint(
     Args:
         entrypoint: a string in the format `<path_to_script>:<flow_func_name>` or a module path
             to a flow function
+        use_placeholder_flow: If True, a placeholder flow will be used if the entrypoint
+            cannot be loaded for any reason (e.g. dependencies are missing). If False, an
+            exception will be raised.
 
     Returns:
         The flow object from the script
@@ -1672,6 +1676,7 @@ def load_flow_from_entrypoint(
         if ":" in entrypoint:
             # split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
             path, func_name = entrypoint.rsplit(":", maxsplit=1)
+
         else:
             path, func_name = entrypoint.rsplit(".", maxsplit=1)
         try:
@@ -1680,14 +1685,15 @@ def load_flow_from_entrypoint(
             raise MissingFlowError(
                 f"Flow function with name {func_name!r} not found in {path!r}. "
             ) from exc
-        except ScriptError as exc:
+        except ScriptError:
             # If the flow has dependencies that are not installed in the current
-            # environment, fallback to loading the flow via AST parsing. The
-            # drawback of this approach is that we're unable to actually load the
-            # function, so we create a placeholder flow that will re-raise this
-            # exception when called.
-
-            flow = load_placeholder_flow(entrypoint=entrypoint, raises=exc)
+            # environment, fallback to loading the flow via AST parsing.
+            if use_placeholder_flow:
+                flow = safe_load_flow_from_entrypoint(entrypoint)
+                if flow is None:
+                    raise
+            else:
+                raise
 
         if not isinstance(flow, Flow):
             raise MissingFlowError(
@@ -1848,6 +1854,147 @@ def load_placeholder_flow(entrypoint: str, raises: Exception):
     return Flow(**arguments)
 
 
+def safe_load_flow_from_entrypoint(entrypoint: str) -> Optional[Flow]:
+    """
+    Load a flow from an entrypoint and return None if an exception is raised.
+
+    Args:
+        entrypoint: a string in the format `<path_to_script>:<flow_func_name>`
+          or a module path to a flow function
+    """
+    func_def, source_code = _entrypoint_definition_and_source(entrypoint)
+    path = None
+    if ":" in entrypoint:
+        path = entrypoint.rsplit(":")[0]
+    namespace = safe_load_namespace(source_code, filepath=path)
+    if func_def.name in namespace:
+        return namespace[func_def.name]
+    else:
+        # If the function is not in the namespace, if may be due to missing dependencies
+        # for the function. We will attempt to compile each annotation and default value
+        # and remove them from the function definition to see if the function can be
+        # compiled without them.
+
+        return _sanitize_and_load_flow(func_def, namespace)
+
+
+def _sanitize_and_load_flow(
+    func_def: Union[ast.FunctionDef, ast.AsyncFunctionDef], namespace: Dict[str, Any]
+) -> Optional[Flow]:
+    """
+    Attempt to load a flow from the function definition after sanitizing the annotations
+    and defaults that can't be compiled.
+
+    Args:
+        func_def: the function definition
+        namespace: the namespace to load the function into
+
+    Returns:
+        The loaded function or None if the function can't be loaded
+        after sanitizing the annotations and defaults.
+    """
+    args = func_def.args.posonlyargs + func_def.args.args + func_def.args.kwonlyargs
+    if func_def.args.vararg:
+        args.append(func_def.args.vararg)
+    if func_def.args.kwarg:
+        args.append(func_def.args.kwarg)
+    # Remove annotations that can't be compiled
+    for arg in args:
+        if arg.annotation is not None:
+            try:
+                code = compile(
+                    ast.Expression(arg.annotation),
+                    filename="<ast>",
+                    mode="eval",
+                )
+                exec(code, namespace)
+            except Exception as e:
+                logger.debug(
+                    "Failed to evaluate annotation for argument %s due to the following error. Ignoring annotation.",
+                    arg.arg,
+                    exc_info=e,
+                )
+                arg.annotation = None
+
+    # Remove defaults that can't be compiled
+    new_defaults = []
+    for default in func_def.args.defaults:
+        try:
+            code = compile(ast.Expression(default), "<ast>", "eval")
+            exec(code, namespace)
+            new_defaults.append(default)
+        except Exception as e:
+            logger.debug(
+                "Failed to evaluate default value %s due to the following error. Ignoring default.",
+                default,
+                exc_info=e,
+            )
+            new_defaults.append(
+                ast.Constant(
+                    value=None, lineno=default.lineno, col_offset=default.col_offset
+                )
+            )
+    func_def.args.defaults = new_defaults
+
+    # Remove kw_defaults that can't be compiled
+    new_kw_defaults = []
+    for default in func_def.args.kw_defaults:
+        if default is not None:
+            try:
+                code = compile(ast.Expression(default), "<ast>", "eval")
+                exec(code, namespace)
+                new_kw_defaults.append(default)
+            except Exception as e:
+                logger.debug(
+                    "Failed to evaluate default value %s due to the following error. Ignoring default.",
+                    default,
+                    exc_info=e,
+                )
+                new_kw_defaults.append(
+                    ast.Constant(
+                        value=None,
+                        lineno=default.lineno,
+                        col_offset=default.col_offset,
+                    )
+                )
+        else:
+            new_kw_defaults.append(
+                ast.Constant(
+                    value=None,
+                    lineno=func_def.lineno,
+                    col_offset=func_def.col_offset,
+                )
+            )
+    func_def.args.kw_defaults = new_kw_defaults
+
+    if func_def.returns is not None:
+        try:
+            code = compile(
+                ast.Expression(func_def.returns), filename="<ast>", mode="eval"
+            )
+            exec(code, namespace)
+        except Exception as e:
+            logger.debug(
+                "Failed to evaluate return annotation due to the following error. Ignoring annotation.",
+                exc_info=e,
+            )
+            func_def.returns = None
+
+    # Attempt to compile the function without annotations and defaults that
+    # can't be compiled
+    try:
+        code = compile(
+            ast.Module(body=[func_def], type_ignores=[]),
+            filename="<ast>",
+            mode="exec",
+        )
+        exec(code, namespace)
+    except Exception as e:
+        logger.debug("Failed to compile: %s", e)
+    else:
+        return namespace.get(func_def.name)
+
+
 def load_flow_arguments_from_entrypoint(
     entrypoint: str, arguments: Optional[Union[List[str], Set[str]]] = None
 ) -> Dict[str, Any]:
@@ -1863,6 +2010,9 @@ def load_flow_arguments_from_entrypoint(
     """
 
     func_def, source_code = _entrypoint_definition_and_source(entrypoint)
+    path = None
+    if ":" in entrypoint:
+        path = entrypoint.rsplit(":")[0]
 
     if arguments is None:
         # If no arguments are provided default to known arguments that are of
@@ -1898,7 +2048,7 @@ def load_flow_arguments_from_entrypoint(
 
                 # if the arg value is not a raw str (i.e. a variable or expression),
                 # then attempt to evaluate it
-                namespace = safe_load_namespace(source_code)
+                namespace = safe_load_namespace(source_code, filepath=path)
                 literal_arg_value = ast.get_source_segment(source_code, keyword.value)
                 cleaned_value = (
                     literal_arg_value.replace("\n", "") if literal_arg_value else ""

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/task_server.py

@@ -9,6 +9,7 @@ from functools import partial
 from typing import List, Optional, Type
 
 import anyio
+from exceptiongroup import BaseExceptionGroup  # novermin
 from websockets.exceptions import InvalidStatusCode
 
 from prefect import Task, get_client
@@ -225,16 +226,21 @@ class TaskServer:
             validated_state=state,
         )
 
-        self._runs_task_group.start_soon(
-            partial(
-                submit_autonomous_task_run_to_engine,
-                task=task,
-                task_run=task_run,
-                parameters=parameters,
-                task_runner=self.task_runner,
-                client=self._client,
+        try:
+            self._runs_task_group.start_soon(
+                partial(
+                    submit_autonomous_task_run_to_engine,
+                    task=task,
+                    task_run=task_run,
+                    parameters=parameters,
+                    task_runner=self.task_runner,
+                    client=self._client,
+                )
+            )
+        except BaseException as exc:
+            logger.exception(
+                f"Failed to submit task run {task_run.id!r} to engine", exc_info=exc
             )
-        )
 
     async def execute_task_run(self, task_run: TaskRun):
         """Execute a task run in the task server."""
@@ -301,6 +307,14 @@ async def serve(*tasks: Task, task_runner: Optional[Type[BaseTaskRunner]] = None
     try:
         await task_server.start()
 
+    except BaseExceptionGroup as exc:  # novermin
+        exceptions = exc.exceptions
+        n_exceptions = len(exceptions)
+        logger.error(
+            f"Task worker stopped with {n_exceptions} exception{'s' if n_exceptions != 1 else ''}:"
+            f"\n" + "\n".join(str(e) for e in exceptions)
+        )
+
     except StopTaskServer:
         logger.info("Task server stopped.")
 

{prefect-client-2.19.8 → prefect-client-2.20.0}/src/prefect/tasks.py

@@ -6,7 +6,6 @@ Module containing the base workflow task class and decorator - for most use case
 
 import datetime
 import inspect
-import os
 from copy import copy
 from functools import partial, update_wrapper
 from typing import (
@@ -76,6 +75,8 @@ P = ParamSpec("P")  # The parameters of the task
 
 logger = get_logger("tasks")
 
+NUM_CHARS_DYNAMIC_KEY: int = 8
+
 
 def task_input_hash(
     context: "TaskRunContext", arguments: Dict[str, Any]
@@ -125,6 +126,28 @@ def exponential_backoff(backoff_factor: float) -> Callable[[int], List[float]]:
     return retry_backoff_callable
 
 
+def _generate_task_key(fn: Callable[..., Any]) -> str:
+    """Generate a task key based on the function name and source code.
+    We may eventually want some sort of top-level namespace here to
+    disambiguate tasks with the same function name in different modules,
+    in a more human-readable way, while avoiding relative import problems (see #12337).
+    As long as the task implementations are unique (even if named the same), we should
+    not have any collisions.
+    Args:
+        fn: The function to generate a task key for.
+    """
+    if not hasattr(fn, "__qualname__"):
+        return to_qualified_name(type(fn))
+
+    qualname = fn.__qualname__.split(".")[-1]
+
+    code_hash = (
+        h[:NUM_CHARS_DYNAMIC_KEY] if (h := hash_objects(fn.__code__)) else "unknown"
+    )
+
+    return f"{qualname}-{code_hash}"
+
+
 @PrefectObjectRegistry.register_instances
 class Task(Generic[P, R]):
     """
@@ -292,17 +315,7 @@ class Task(Generic[P, R]):
 
         self.tags = set(tags if tags else [])
 
-        if not hasattr(self.fn, "__qualname__"):
-            self.task_key = to_qualified_name(type(self.fn))
-        else:
-            try:
-                task_origin_hash = hash_objects(
-                    self.name, os.path.abspath(inspect.getsourcefile(self.fn))
-                )
-            except TypeError:
-                task_origin_hash = "unknown-source-file"
-
-            self.task_key = f"{self.fn.__qualname__}-{task_origin_hash}"
+        self.task_key = _generate_task_key(self.fn)
 
         self.cache_key_fn = cache_key_fn
         self.cache_expiration = cache_expiration