prefect-client 3.1.5__py3-none-any.whl → 3.1.6__py3-none-any.whl

prefect/utilities/filesystem.py

@@ -5,14 +5,16 @@ Utilities for working with file systems
 import os
 import pathlib
 import threading
+from collections.abc import Iterable
 from contextlib import contextmanager
 from pathlib import Path, PureWindowsPath
-from typing import Optional, Union, cast
+from typing import AnyStr, Optional, Union, cast
 
-import fsspec
+# fsspec has no stubs, see https://github.com/fsspec/filesystem_spec/issues/625
+import fsspec  # type: ignore
 import pathspec
-from fsspec.core import OpenFile
-from fsspec.implementations.local import LocalFileSystem
+from fsspec.core import OpenFile  # type: ignore
+from fsspec.implementations.local import LocalFileSystem  # type: ignore
 
 import prefect
 
@@ -33,8 +35,10 @@ def create_default_ignore_file(path: str) -> bool:
 
 
 def filter_files(
-    root: str = ".", ignore_patterns: Optional[list] = None, include_dirs: bool = True
-) -> set:
+    root: str = ".",
+    ignore_patterns: Optional[Iterable[AnyStr]] = None,
+    include_dirs: bool = True,
+) -> set[str]:
     """
     This function accepts a root directory path and a list of file patterns to ignore, and returns
     a list of files that excludes those that should be ignored.
@@ -51,7 +55,7 @@ def filter_files(
     return included_files
 
 
-chdir_lock = threading.Lock()
+chdir_lock: threading.Lock = threading.Lock()
 
 
 def _normalize_path(path: Union[str, Path]) -> str:
@@ -103,33 +107,32 @@ def tmpchdir(path: str):
 def filename(path: str) -> str:
     """Extract the file name from a path with remote file system support"""
     try:
-        of: OpenFile = cast(OpenFile, fsspec.open(path))
-        sep = of.fs.sep
+        of: OpenFile = cast(OpenFile, fsspec.open(path))  # type: ignore  # no typing stubs available
+        sep = cast(str, of.fs.sep)  # type: ignore  # no typing stubs available
     except (ImportError, AttributeError):
         sep = "\\" if "\\" in path else "/"
     return path.split(sep)[-1]
 
 
-def is_local_path(path: Union[str, pathlib.Path, OpenFile]):
+def is_local_path(path: Union[str, pathlib.Path, OpenFile]) -> bool:
     """Check if the given path points to a local or remote file system"""
     if isinstance(path, str):
         try:
-            of = fsspec.open(path)
+            of = cast(OpenFile, fsspec.open(path))  # type: ignore  # no typing stubs available
         except ImportError:
             # The path is a remote file system that uses a lib that is not installed
             return False
     elif isinstance(path, pathlib.Path):
         return True
-    elif isinstance(path, OpenFile):
-        of = path
     else:
-        raise TypeError(f"Invalid path of type {type(path).__name__!r}")
+        of = path
 
     return isinstance(of.fs, LocalFileSystem)
 
 
 def to_display_path(
-    path: Union[pathlib.Path, str], relative_to: Union[pathlib.Path, str] = None
+    path: Union[pathlib.Path, str],
+    relative_to: Optional[Union[pathlib.Path, str]] = None,
 ) -> str:
     """
     Convert a path to a displayable path. The absolute path or relative path to the

prefect/utilities/hashing.py

@@ -1,21 +1,17 @@
 import hashlib
-import sys
 from functools import partial
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Callable, Optional, Union
 
-import cloudpickle
+import cloudpickle  # type: ignore  # no stubs available
 
 from prefect.exceptions import HashError
 from prefect.serializers import JSONSerializer
 
-if sys.version_info[:2] >= (3, 9):
-    _md5 = partial(hashlib.md5, usedforsecurity=False)
-else:
-    _md5 = hashlib.md5
+_md5 = partial(hashlib.md5, usedforsecurity=False)
 
 
-def stable_hash(*args: Union[str, bytes], hash_algo=_md5) -> str:
+def stable_hash(*args: Union[str, bytes], hash_algo: Callable[..., Any] = _md5) -> str:
     """Given some arguments, produces a stable 64-bit hash of their contents.
 
     Supports bytes and strings. Strings will be UTF-8 encoded.
@@ -35,7 +31,7 @@ def stable_hash(*args: Union[str, bytes], hash_algo=_md5) -> str:
     return h.hexdigest()
 
 
-def file_hash(path: str, hash_algo=_md5) -> str:
+def file_hash(path: str, hash_algo: Callable[..., Any] = _md5) -> str:
     """Given a path to a file, produces a stable hash of the file contents.
 
     Args:
@@ -50,7 +46,10 @@ def file_hash(path: str, hash_algo=_md5) -> str:
 
 
 def hash_objects(
-    *args, hash_algo=_md5, raise_on_failure: bool = False, **kwargs
+    *args: Any,
+    hash_algo: Callable[..., Any] = _md5,
+    raise_on_failure: bool = False,
+    **kwargs: Any,
 ) -> Optional[str]:
     """
     Attempt to hash objects by dumping to JSON or serializing with cloudpickle.
@@ -77,7 +76,7 @@ def hash_objects(
         json_error = str(e)
 
     try:
-        return stable_hash(cloudpickle.dumps((args, kwargs)), hash_algo=hash_algo)
+        return stable_hash(cloudpickle.dumps((args, kwargs)), hash_algo=hash_algo)  # type: ignore[reportUnknownMemberType]
     except Exception as e:
         pickle_error = str(e)
 

prefect/utilities/importtools.py

@@ -5,20 +5,23 @@ import os
 import runpy
 import sys
 import warnings
+from collections.abc import Iterable, Sequence
 from importlib.abc import Loader, MetaPathFinder
 from importlib.machinery import ModuleSpec
+from io import TextIOWrapper
+from logging import Logger
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from types import ModuleType
-from typing import Any, Callable, Dict, Iterable, NamedTuple, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, Optional, Union
 
-import fsspec
+import fsspec  # type: ignore  # no typing stubs available
 
 from prefect.exceptions import ScriptError
 from prefect.logging.loggers import get_logger
 from prefect.utilities.filesystem import filename, is_local_path, tmpchdir
 
-logger = get_logger(__name__)
+logger: Logger = get_logger(__name__)
 
 
 def to_qualified_name(obj: Any) -> str:
@@ -70,7 +73,9 @@ def from_qualified_name(name: str) -> Any:
     return getattr(module, attr_name)
 
 
-def objects_from_script(path: str, text: Union[str, bytes] = None) -> Dict[str, Any]:
+def objects_from_script(
+    path: str, text: Optional[Union[str, bytes]] = None
+) -> dict[str, Any]:
     """
     Run a python script and return all the global variables
 
@@ -97,7 +102,7 @@ def objects_from_script(path: str, text: Union[str, bytes] = None) -> Dict[str,
         ScriptError: if the script raises an exception during execution
     """
 
-    def run_script(run_path: str):
+    def run_script(run_path: str) -> dict[str, Any]:
         # Cast to an absolute path before changing directories to ensure relative paths
         # are not broken
         abs_run_path = os.path.abspath(run_path)
@@ -120,7 +125,9 @@ def objects_from_script(path: str, text: Union[str, bytes] = None) -> Dict[str,
     else:
         if not is_local_path(path):
             # Remote paths need to be local to run
-            with fsspec.open(path) as f:
+            with fsspec.open(path) as f:  # type: ignore  # no typing stubs available
+                if TYPE_CHECKING:
+                    assert isinstance(f, TextIOWrapper)
                 contents = f.read()
             return objects_from_script(path, contents)
         else:
@@ -156,6 +163,10 @@ def load_script_as_module(path: str) -> ModuleType:
         # Support explicit relative imports i.e. `from .foo import bar`
         submodule_search_locations=[parent_path, working_directory],
     )
+    if TYPE_CHECKING:
+        assert spec is not None
+        assert spec.loader is not None
+
     module = importlib.util.module_from_spec(spec)
     sys.modules["__prefect_loader__"] = module
 
@@ -189,7 +200,7 @@ def load_module(module_name: str) -> ModuleType:
         sys.path.remove(working_directory)
 
 
-def import_object(import_path: str):
+def import_object(import_path: str) -> Any:
     """
     Load an object from an import path.
 
@@ -228,22 +239,20 @@ class DelayedImportErrorModule(ModuleType):
     [1]: https://github.com/scientific-python/lazy_loader
     """
 
-    def __init__(self, error_message, help_message, *args, **kwargs):
+    def __init__(self, error_message: str, help_message: Optional[str] = None) -> None:
         self.__error_message = error_message
-        self.__help_message = (
-            help_message or "Import errors for this module are only reported when used."
-        )
-        super().__init__(*args, **kwargs)
+        if not help_message:
+            help_message = "Import errors for this module are only reported when used."
+        super().__init__("DelayedImportErrorModule", help_message)
 
-    def __getattr__(self, attr):
-        if attr in ("__class__", "__file__", "__help_message"):
-            super().__getattr__(attr)
-        else:
-            raise ModuleNotFoundError(self.__error_message)
+    def __getattr__(self, attr: str) -> Any:
+        if attr == "__file__":  # not set but should result in an attribute error?
+            return super().__getattr__(attr)
+        raise ModuleNotFoundError(self.__error_message)
 
 
 def lazy_import(
-    name: str, error_on_import: bool = False, help_message: str = ""
+    name: str, error_on_import: bool = False, help_message: Optional[str] = None
 ) -> ModuleType:
     """
     Create a lazily-imported module to use in place of the module of the given name.
@@ -282,13 +291,13 @@ def lazy_import(
         if error_on_import:
             raise ModuleNotFoundError(import_error_message)
 
-        return DelayedImportErrorModule(
-            import_error_message, help_message, "DelayedImportErrorModule"
-        )
+        return DelayedImportErrorModule(import_error_message, help_message)
 
     module = importlib.util.module_from_spec(spec)
     sys.modules[name] = module
 
+    if TYPE_CHECKING:
+        assert spec.loader is not None
     loader = importlib.util.LazyLoader(spec.loader)
     loader.exec_module(module)
 
@@ -317,13 +326,13 @@ class AliasedModuleFinder(MetaPathFinder):
 
         Aliases apply to all modules nested within an alias.
         """
-        self.aliases = aliases
+        self.aliases: list[AliasedModuleDefinition] = list(aliases)
 
     def find_spec(
         self,
         fullname: str,
-        path=None,
-        target=None,
+        path: Optional[Sequence[str]] = None,
+        target: Optional[ModuleType] = None,
     ) -> Optional[ModuleSpec]:
         """
         The fullname is the imported path, e.g. "foo.bar". If there is an alias "phi"
@@ -334,6 +343,7 @@ class AliasedModuleFinder(MetaPathFinder):
             if fullname.startswith(alias):
                 # Retrieve the spec of the real module
                 real_spec = importlib.util.find_spec(fullname.replace(alias, real, 1))
+                assert real_spec is not None
                 # Create a new spec for the alias
                 return ModuleSpec(
                     fullname,
@@ -354,7 +364,7 @@ class AliasedModuleLoader(Loader):
         self.callback = callback
         self.real_spec = real_spec
 
-    def exec_module(self, _: ModuleType) -> None:
+    def exec_module(self, module: ModuleType) -> None:
         root_module = importlib.import_module(self.real_spec.name)
         if self.callback is not None:
             self.callback(self.alias)
@@ -363,7 +373,7 @@ class AliasedModuleLoader(Loader):
 
 def safe_load_namespace(
     source_code: str, filepath: Optional[str] = None
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Safely load a namespace from source code, optionally handling relative imports.
 
@@ -380,7 +390,7 @@ def safe_load_namespace(
     """
     parsed_code = ast.parse(source_code)
 
-    namespace: Dict[str, Any] = {"__name__": "prefect_safe_namespace_loader"}
+    namespace: dict[str, Any] = {"__name__": "prefect_safe_namespace_loader"}
 
     # Remove the body of the if __name__ == "__main__": block
     new_body = [node for node in parsed_code.body if not _is_main_block(node)]
@@ -427,6 +437,9 @@ def safe_load_namespace(
                     try:
                         if node.level > 0:
                             # For relative imports, use the parent package to inform the import
+                            if TYPE_CHECKING:
+                                assert temp_module is not None
+                                assert temp_module.__package__ is not None
                             package_parts = temp_module.__package__.split(".")
                             if len(package_parts) < node.level:
                                 raise ImportError(

prefect/utilities/math.py

@@ -2,7 +2,9 @@ import math
 import random
 
 
-def poisson_interval(average_interval, lower=0, upper=1):
+def poisson_interval(
+    average_interval: float, lower: float = 0, upper: float = 1
+) -> float:
     """
     Generates an "inter-arrival time" for a Poisson process.
 
@@ -16,12 +18,12 @@ def poisson_interval(average_interval, lower=0, upper=1):
     return -math.log(max(1 - random.uniform(lower, upper), 1e-10)) * average_interval
 
 
-def exponential_cdf(x, average_interval):
+def exponential_cdf(x: float, average_interval: float) -> float:
     ld = 1 / average_interval
     return 1 - math.exp(-ld * x)
 
 
-def lower_clamp_multiple(k):
+def lower_clamp_multiple(k: float) -> float:
     """
     Computes a lower clamp multiple that can be used to bound a random variate drawn
     from an exponential distribution.
@@ -38,7 +40,9 @@ def lower_clamp_multiple(k):
     return math.log(max(2**k / (2**k - 1), 1e-10), 2)
 
 
-def clamped_poisson_interval(average_interval, clamping_factor=0.3):
+def clamped_poisson_interval(
+    average_interval: float, clamping_factor: float = 0.3
+) -> float:
     """
     Bounds Poisson "inter-arrival times" to a range defined by the clamping factor.
 
@@ -57,7 +61,7 @@ def clamped_poisson_interval(average_interval, clamping_factor=0.3):
     return poisson_interval(average_interval, lower_rv, upper_rv)
 
 
-def bounded_poisson_interval(lower_bound, upper_bound):
+def bounded_poisson_interval(lower_bound: float, upper_bound: float) -> float:
     """
     Bounds Poisson "inter-arrival times" to a range.
 

prefect/utilities/names.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-import coolname
+import coolname  # type: ignore # the version after coolname 2.2.0 should have stubs.
 
 OBFUSCATED_PREFIX = "****"
 
@@ -42,7 +42,7 @@ def generate_slug(n_words: int) -> str:
     return "-".join(words)
 
 
-def obfuscate(s: Any, show_tail=False) -> str:
+def obfuscate(s: Any, show_tail: bool = False) -> str:
     """
     Obfuscates any data type's string representation. See `obfuscate_string`.
     """
@@ -52,7 +52,7 @@ def obfuscate(s: Any, show_tail=False) -> str:
     return obfuscate_string(str(s), show_tail=show_tail)
 
 
-def obfuscate_string(s: str, show_tail=False) -> str:
+def obfuscate_string(s: str, show_tail: bool = False) -> str:
     """
     Obfuscates a string by returning a new string of 8 characters. If the input
     string is longer than 10 characters and show_tail is True, then up to 4 of