prefect-client 3.8.4.dev5__tar.gz → 3.8.4.dev7__tar.gz

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.8.4.dev5
+Version: 3.8.4.dev7
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect_client-3.8.4.dev7/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.4.dev7"
+__build_date__ = "2026-08-25 08:17:48.726889+00:00"
+__git_commit__ = "8396d0cf707213afcd9de41893353b08067edb2c"
+__dirty__ = False

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/src/prefect/bundles/__init__.py

@@ -11,6 +11,7 @@ import logging
 import multiprocessing
 import multiprocessing.context
 import os
+import stat
 import subprocess
 import sys
 import tempfile
@@ -395,6 +396,41 @@ def _pickle_local_modules_by_value(flow: Flow[Any, Any]):
                 )
 
 
+def _resolve_include_files_base_dir(value: Path | str) -> Path:
+    """Resolve and validate an explicitly configured include-files base directory."""
+    try:
+        candidate = Path(value).expanduser()
+    except RuntimeError as exc:
+        raise ValueError(
+            f"Invalid include_files_base_dir {str(value)!r}: {exc}"
+        ) from exc
+
+    if not candidate.is_absolute():
+        candidate = Path.cwd() / candidate
+
+    try:
+        base_dir = candidate.resolve(strict=True)
+        if not stat.S_ISDIR(base_dir.stat().st_mode):
+            raise ValueError(
+                f"include_files_base_dir {str(value)!r} must be a directory."
+            )
+
+        # Open the directory to verify that collection can read it. `os.access` is
+        # not sufficient because its result can differ from the actual operation.
+        with os.scandir(base_dir):
+            pass
+    except FileNotFoundError as exc:
+        raise ValueError(
+            f"include_files_base_dir {str(value)!r} does not exist."
+        ) from exc
+    except NotADirectoryError as exc:
+        raise ValueError(
+            f"include_files_base_dir {str(value)!r} must be a directory."
+        ) from exc
+
+    return base_dir
+
+
 def create_bundle_for_flow_run(
     flow: Flow[Any, Any],
     flow_run: FlowRun,
@@ -463,12 +499,16 @@ def create_bundle_for_flow_run(
     files_key: str | None = None
     zip_path: Path | None = None
     include_files = getattr(flow, "include_files", None)
+    include_files_base_dir = getattr(flow, "include_files_base_dir", None)
 
     if include_files:
         try:
-            # Get base directory from flow file location
-            flow_file = Path(inspect.getfile(flow.fn))
-            base_dir = flow_file.parent.resolve()
+            if include_files_base_dir is None:
+                # Preserve the existing default relative to the flow definition.
+                flow_file = Path(inspect.getfile(flow.fn))
+                base_dir = flow_file.parent.resolve()
+            else:
+                base_dir = _resolve_include_files_base_dir(include_files_base_dir)
 
             # Pipeline: collect -> filter -> check -> zip
             collector = FileCollector(base_dir)
@@ -498,6 +538,8 @@ def create_bundle_for_flow_run(
                         files_key,
                     )
         except (OSError, TypeError, AttributeError) as e:
+            if include_files_base_dir is not None:
+                raise
             # Handle cases where flow has no file (dynamic flow) or other IO errors
             logger.warning(
                 "Could not collect included files: %s. Files will not be bundled.",

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/src/prefect/bundles/_ignore_filter.py

@@ -87,23 +87,9 @@ def _read_ignore_file(path: Path) -> list[str]:
     return [line for line in lines if line.strip() and not line.startswith("#")]
 
 
-def load_ignore_patterns(flow_dir: Path) -> list[str]:
-    """
-    Load patterns from cascading .prefectignore files.
-
-    Load order (patterns combined via union):
-    1. Project root .prefectignore (if found via pyproject.toml detection)
-    2. Flow directory .prefectignore (if different from project root)
-
-    Missing .prefectignore files emit debug log, not warning.
-
-    Args:
-        flow_dir: Flow file's directory (base for relative paths).
-
-    Returns:
-        Combined list of pattern strings from all .prefectignore files.
-    """
-    patterns: list[str] = []
+def _load_ignore_pattern_sources(flow_dir: Path) -> list[tuple[Path, list[str]]]:
+    """Load ignore patterns together with the directory they are relative to."""
+    sources: list[tuple[Path, list[str]]] = []
 
     # 1. Find and load project root .prefectignore
     project_root = find_project_root(flow_dir)
@@ -111,7 +97,7 @@ def load_ignore_patterns(flow_dir: Path) -> list[str]:
         project_ignore = project_root / ".prefectignore"
         if project_ignore.exists():
             logger.debug(f"Loading .prefectignore from project root: {project_ignore}")
-            patterns.extend(_read_ignore_file(project_ignore))
+            sources.append((project_root.resolve(), _read_ignore_file(project_ignore)))
         else:
             logger.debug(f"No .prefectignore found at project root: {project_root}")
     else:
@@ -123,11 +109,34 @@ def load_ignore_patterns(flow_dir: Path) -> list[str]:
         # Only load if different from project root's .prefectignore
         if project_root is None or flow_dir.resolve() != project_root.resolve():
             logger.debug(f"Loading .prefectignore from flow directory: {flow_ignore}")
-            patterns.extend(_read_ignore_file(flow_ignore))
+            sources.append((flow_dir.resolve(), _read_ignore_file(flow_ignore)))
     else:
         logger.debug(f"No .prefectignore found in flow directory: {flow_dir}")
 
-    return patterns
+    return sources
+
+
+def load_ignore_patterns(flow_dir: Path) -> list[str]:
+    """
+    Load patterns from cascading .prefectignore files.
+
+    Load order (later matching patterns override earlier patterns):
+    1. Project root .prefectignore (if found via pyproject.toml detection)
+    2. Flow directory .prefectignore (if different from project root)
+
+    Missing .prefectignore files emit debug log, not warning.
+
+    Args:
+        flow_dir: Flow file's directory (base for relative paths).
+
+    Returns:
+        Combined list of pattern strings from all .prefectignore files.
+    """
+    return [
+        pattern
+        for _, patterns in _load_ignore_pattern_sources(flow_dir)
+        for pattern in patterns
+    ]
 
 
 class IgnoreFilter:
@@ -155,14 +164,16 @@ class IgnoreFilter:
             flow_dir: Base directory for file collection (typically flow file's parent).
         """
         self.flow_dir = flow_dir.resolve()
-        self._spec: pathspec.GitIgnoreSpec | None = None
+        self._specs: list[tuple[Path, pathspec.GitIgnoreSpec]] = []
         self._load_patterns()
 
     def _load_patterns(self) -> None:
         """Load patterns and compile into pathspec."""
-        patterns = load_ignore_patterns(self.flow_dir)
-        if patterns:
-            self._spec = pathspec.GitIgnoreSpec.from_lines(patterns)
+        for pattern_root, patterns in _load_ignore_pattern_sources(self.flow_dir):
+            if patterns:
+                self._specs.append(
+                    (pattern_root, pathspec.GitIgnoreSpec.from_lines(patterns))
+                )
 
     def filter(
         self,
@@ -202,11 +213,25 @@ class IgnoreFilter:
                 result.excluded_by_ignore.append(file)
                 continue
 
-            # Check against ignore spec
+            # Check against ignore specs in cascade order. A later source only
+            # overrides the current decision when one of its patterns matches.
             excluded = False
-            if self._spec is not None:
-                if self._spec.match_file(rel_path):
-                    excluded = True
+            for pattern_root, spec in self._specs:
+                try:
+                    pattern_path = str(file.relative_to(pattern_root))
+                except ValueError:
+                    try:
+                        pattern_path = str(file.resolve().relative_to(pattern_root))
+                    except ValueError:
+                        continue
+
+                normalized_path = pathspec.util.normalize_file(pattern_path)
+                if any(
+                    pattern.include is not None
+                    and pattern.match_file(normalized_path) is not None
+                    for pattern in spec.patterns
+                ):
+                    excluded = spec.match_file(normalized_path)
 
             if excluded:
                 result.excluded_by_ignore.append(file)

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/src/prefect/flows.py

@@ -2397,6 +2397,10 @@ class InfrastructureBoundFlow(Flow[P, R]):
         job_variables: Infrastructure configuration that will override the base job
             configuration of the work pool.
         launcher: Optional upload and execution launcher overrides.
+        include_files: Optional file patterns to include with the flow bundle.
+        include_files_base_dir: Optional base directory for `include_files`. Relative
+            paths are resolved from the working directory when the bundle is created.
+            Defaults to the flow file's directory.
         worker_cls: The class of the worker to use to spin up infrastructure and submit
             the flow to it.
     """
@@ -2409,6 +2413,7 @@ class InfrastructureBoundFlow(Flow[P, R]):
         worker_cls: type["BaseWorker[Any, Any, Any]"],
         launcher: BundleLauncher | None = None,
         include_files: Sequence[str] | None = None,
+        include_files_base_dir: Path | str | None = None,
         **kwargs: Any,
     ):
         super().__init__(*args, **kwargs)
@@ -2419,6 +2424,9 @@ class InfrastructureBoundFlow(Flow[P, R]):
         self.include_files: list[str] | None = (
             list(include_files) if include_files is not None else None
         )
+        self.include_files_base_dir: str | None = (
+            str(include_files_base_dir) if include_files_base_dir is not None else None
+        )
 
     @overload
     def __call__(self: "Flow[P, NoReturn]", *args: P.args, **kwargs: P.kwargs) -> None:
@@ -2648,7 +2656,7 @@ class InfrastructureBoundFlow(Flow[P, R]):
             get_result_store,
             resolve_result_storage,
         )
-        from prefect.states import Pending, Scheduled
+        from prefect.states import Failed, Pending, Scheduled
         from prefect.tasks import Task
 
         # Get parameters to error early if they are invalid
@@ -2753,14 +2761,28 @@ class InfrastructureBoundFlow(Flow[P, R]):
                 parent_task_run_id=getattr(parent_task_run, "id", None),
             )
 
-            result = create_bundle_for_flow_run(flow=flow, flow_run=flow_run)
-            upload_bundle_to_storage(
-                result["bundle"],
-                bundle_key,
-                upload_command,
-                zip_path=result["zip_path"],
-                upload_step=upload_step,
-            )
+            try:
+                result = create_bundle_for_flow_run(flow=flow, flow_run=flow_run)
+                upload_bundle_to_storage(
+                    result["bundle"],
+                    bundle_key,
+                    upload_command,
+                    zip_path=result["zip_path"],
+                    upload_step=upload_step,
+                )
+            except Exception as exc:
+                try:
+                    client.set_flow_run_state(
+                        flow_run.id,
+                        state=Failed(message=f"Flow run submission failed: {exc}"),
+                        force=True,
+                    )
+                except Exception:
+                    logger.exception(
+                        "Failed to update flow run %s after submission failed",
+                        flow_run.id,
+                    )
+                raise
 
             # Set flow run to scheduled now that the bundle is uploaded and ready to be executed
             client.set_flow_run_state(flow_run.id, state=Scheduled())
@@ -2795,6 +2817,7 @@ class InfrastructureBoundFlow(Flow[P, R]):
         job_variables: Optional[dict[str, Any]] = None,
         launcher: BundleLauncher | None = NotSet,  # type: ignore
         include_files: Optional[list[str]] = NotSet,  # type: ignore
+        include_files_base_dir: Path | str | None = NotSet,  # type: ignore
     ) -> "InfrastructureBoundFlow[P, R]":
         new_flow = super().with_options(
             name=name,
@@ -2828,6 +2851,9 @@ class InfrastructureBoundFlow(Flow[P, R]):
             include_files=include_files
             if include_files is not NotSet
             else self.include_files,
+            include_files_base_dir=include_files_base_dir
+            if include_files_base_dir is not NotSet
+            else self.include_files_base_dir,
         )
         return new_infrastructure_bound_flow
 
@@ -2839,7 +2865,25 @@ def bind_flow_to_infrastructure(
     job_variables: dict[str, Any] | None = None,
     launcher: BundleLauncher | None = None,
     include_files: Sequence[str] | None = None,
+    *,
+    include_files_base_dir: Path | str | None = None,
 ) -> InfrastructureBoundFlow[P, R]:
+    """Bind a flow to execution on a specific infrastructure work pool.
+
+    Args:
+        flow: The flow to bind.
+        work_pool: The name of the work pool to use.
+        worker_cls: The worker class that submits the flow.
+        job_variables: Infrastructure overrides for the work pool's base job template.
+        launcher: Optional upload and execution launcher overrides.
+        include_files: Optional file patterns to include with the flow bundle.
+        include_files_base_dir: Optional base directory for `include_files`. Relative
+            paths are resolved from the working directory when the bundle is created.
+            Defaults to the flow file's directory.
+
+    Returns:
+        An infrastructure-bound copy of the flow.
+    """
     new = InfrastructureBoundFlow[P, R](
         flow.fn,
         work_pool=work_pool,
@@ -2847,6 +2891,7 @@ def bind_flow_to_infrastructure(
         worker_cls=worker_cls,
         launcher=launcher,
         include_files=include_files,
+        include_files_base_dir=include_files_base_dir,
     )
     # Copy all attributes from the original flow
     for attr, value in flow.__dict__.items():
@@ -2856,6 +2901,9 @@ def bind_flow_to_infrastructure(
     new.worker_cls = worker_cls
     new.launcher = normalize_launcher(launcher)
     new.include_files = list(include_files) if include_files is not None else None
+    new.include_files_base_dir = (
+        str(include_files_base_dir) if include_files_base_dir is not None else None
+    )
     return new
 
 

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/src/prefect/logging/handlers.py

@@ -9,7 +9,7 @@ import traceback
 import uuid
 import warnings
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, Callable, Dict, TextIO, Type
+from typing import TYPE_CHECKING, Any, Callable, Dict, TextIO, Type, cast
 
 from rich.console import Console
 from rich.highlighter import Highlighter, NullHighlighter
@@ -334,8 +334,29 @@ class _SafeStreamHandler(StreamHandler):
     it to handleError(), which prints a noisy traceback to sys.stderr. We
     suppress that for ValueError so background threads logging after stream
     teardown stay silent.
+
+    Context-managed locking also prevents asynchronous cancellation from
+    leaving the handler locked on Python 3.12 and earlier.
     """
 
+    def handle(self, record: logging.LogRecord) -> bool:
+        filtered = self.filter(record)
+        if isinstance(filtered, logging.LogRecord):
+            record = filtered
+        if filtered:
+            lock = self.lock
+            assert lock is not None
+            with lock:
+                self.emit(record)
+        return cast(bool, filtered)
+
+    def flush(self) -> None:
+        lock = self.lock
+        assert lock is not None
+        with lock:
+            if self.stream and hasattr(self.stream, "flush"):
+                self.stream.flush()
+
     def handleError(self, record: logging.LogRecord) -> None:
         _, exc, _ = sys.exc_info()
         if isinstance(exc, ValueError) and "closed file" in str(exc):

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/src/prefect/workers/base.py

@@ -1146,7 +1146,18 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
             worker_id=self.backend_id,
         )
 
-        bundle_result = create_bundle_for_flow_run(flow=flow, flow_run=flow_run)
+        try:
+            bundle_result = create_bundle_for_flow_run(flow=flow, flow_run=flow_run)
+        except Exception as exc:
+            logger.exception(
+                "Failed to create execution bundle for flow run '%s'.", flow_run.id
+            )
+            message = (
+                f"Flow run bundle could not be created: {type(exc).__name__}: {exc}"
+            )
+            await self._propose_crashed_state(flow_run, message, client=self.client)
+            return
+
         bundle = bundle_result["bundle"]
         zip_path = bundle_result["zip_path"]
 
@@ -1290,7 +1301,7 @@ class BaseWorker(abc.ABC, Generic[C, V, R]):
 
         seconds_since_last_poll = (
             prefect.types._datetime.now("UTC") - self._last_polled_time
-        ).seconds
+        ).total_seconds()
 
         is_still_polling = seconds_since_last_poll <= threshold_seconds
 

{prefect_client-3.8.4.dev5 → prefect_client-3.8.4.dev7}/src/prefect/workers/process.py

@@ -280,7 +280,17 @@ class ProcessWorker(
             worker_id=self.backend_id,
         )
 
-        result = create_bundle_for_flow_run(flow=flow, flow_run=flow_run)
+        try:
+            result = create_bundle_for_flow_run(flow=flow, flow_run=flow_run)
+        except Exception as exc:
+            logger.exception(
+                "Failed to create execution bundle for flow run '%s'.", flow_run.id
+            )
+            message = (
+                f"Flow run bundle could not be created: {type(exc).__name__}: {exc}"
+            )
+            await self._propose_crashed_state(flow_run, message)
+            return
 
         logger.debug("Executing flow run bundle in subprocess...")
         try:

prefect_client-3.8.4.dev5/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.8.4.dev5"
-__build_date__ = "2026-08-21 08:16:02.661742+00:00"
-__git_commit__ = "00dd3e99c172c437e7c3e7415a0043732cac2f31"
-__dirty__ = False