metaflow 2.15.4__py2.py3-none-any.whl → 2.15.6__py2.py3-none-any.whl

metaflow/_vendor/typeguard/_functions.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 import warnings
-from typing import Any, Callable, NoReturn, TypeVar, overload
+from typing import Any, Callable, NoReturn, TypeVar, Union, overload
 
 from . import _suppression
 from ._checkers import BINARY_MAGIC_METHODS, check_type_internal
@@ -32,8 +32,7 @@ def check_type(
     forward_ref_policy: ForwardRefPolicy = ...,
     typecheck_fail_callback: TypeCheckFailCallback | None = ...,
     collection_check_strategy: CollectionCheckStrategy = ...,
-) -> T:
-    ...
+) -> T: ...
 
 
 @overload
@@ -44,8 +43,7 @@ def check_type(
     forward_ref_policy: ForwardRefPolicy = ...,
     typecheck_fail_callback: TypeCheckFailCallback | None = ...,
     collection_check_strategy: CollectionCheckStrategy = ...,
-) -> Any:
-    ...
+) -> Any: ...
 
 
 def check_type(
@@ -53,7 +51,7 @@ def check_type(
     expected_type: Any,
     *,
     forward_ref_policy: ForwardRefPolicy = TypeCheckConfiguration().forward_ref_policy,
-    typecheck_fail_callback: (TypeCheckFailCallback | None) = (
+    typecheck_fail_callback: TypeCheckFailCallback | None = (
         TypeCheckConfiguration().typecheck_fail_callback
     ),
     collection_check_strategy: CollectionCheckStrategy = (
@@ -80,7 +78,7 @@ def check_type(
     corresponding fields in :class:`TypeCheckConfiguration`.
 
     :param value: value to be checked against ``expected_type``
-    :param expected_type: a class or generic type instance
+    :param expected_type: a class or generic type instance, or a tuple of such things
     :param forward_ref_policy: see :attr:`TypeCheckConfiguration.forward_ref_policy`
     :param typecheck_fail_callback:
         see :attr`TypeCheckConfiguration.typecheck_fail_callback`
@@ -90,6 +88,9 @@ def check_type(
     :raises TypeCheckError: if there is a type mismatch
 
     """
+    if type(expected_type) is tuple:
+        expected_type = Union[expected_type]
+
     config = TypeCheckConfiguration(
         forward_ref_policy=forward_ref_policy,
         typecheck_fail_callback=typecheck_fail_callback,
@@ -244,7 +245,7 @@ def check_variable_assignment(
     value: object, varname: str, annotation: Any, memo: TypeCheckMemo
 ) -> Any:
     if _suppression.type_checks_suppressed:
-        return
+        return value
 
     try:
         check_type_internal(value, annotation, memo)
@@ -262,36 +263,36 @@ def check_variable_assignment(
 def check_multi_variable_assignment(
     value: Any, targets: list[dict[str, Any]], memo: TypeCheckMemo
 ) -> Any:
-    if _suppression.type_checks_suppressed:
-        return
-
     if max(len(target) for target in targets) == 1:
         iterated_values = [value]
     else:
         iterated_values = list(value)
 
-    for expected_types in targets:
-        value_index = 0
-        for ann_index, (varname, expected_type) in enumerate(expected_types.items()):
-            if varname.startswith("*"):
-                varname = varname[1:]
-                keys_left = len(expected_types) - 1 - ann_index
-                next_value_index = len(iterated_values) - keys_left
-                obj: object = iterated_values[value_index:next_value_index]
-                value_index = next_value_index
-            else:
-                obj = iterated_values[value_index]
-                value_index += 1
-
-            try:
-                check_type_internal(obj, expected_type, memo)
-            except TypeCheckError as exc:
-                qualname = qualified_name(obj, add_class_prefix=True)
-                exc.append_path_element(f"value assigned to {varname} ({qualname})")
-                if memo.config.typecheck_fail_callback:
-                    memo.config.typecheck_fail_callback(exc, memo)
+    if not _suppression.type_checks_suppressed:
+        for expected_types in targets:
+            value_index = 0
+            for ann_index, (varname, expected_type) in enumerate(
+                expected_types.items()
+            ):
+                if varname.startswith("*"):
+                    varname = varname[1:]
+                    keys_left = len(expected_types) - 1 - ann_index
+                    next_value_index = len(iterated_values) - keys_left
+                    obj: object = iterated_values[value_index:next_value_index]
+                    value_index = next_value_index
                 else:
-                    raise
+                    obj = iterated_values[value_index]
+                    value_index += 1
+
+                try:
+                    check_type_internal(obj, expected_type, memo)
+                except TypeCheckError as exc:
+                    qualname = qualified_name(obj, add_class_prefix=True)
+                    exc.append_path_element(f"value assigned to {varname} ({qualname})")
+                    if memo.config.typecheck_fail_callback:
+                        memo.config.typecheck_fail_callback(exc, memo)
+                    else:
+                        raise
 
     return iterated_values[0] if len(iterated_values) == 1 else iterated_values
 

metaflow/_vendor/typeguard/_pytest_plugin.py

@@ -2,16 +2,29 @@ from __future__ import annotations
 
 import sys
 import warnings
-
-from pytest import Config, Parser
+from typing import TYPE_CHECKING, Any, Literal
 
 from metaflow._vendor.typeguard._config import CollectionCheckStrategy, ForwardRefPolicy, global_config
 from metaflow._vendor.typeguard._exceptions import InstrumentationWarning
 from metaflow._vendor.typeguard._importhook import install_import_hook
 from metaflow._vendor.typeguard._utils import qualified_name, resolve_reference
 
+if TYPE_CHECKING:
+    from pytest import Config, Parser
+
 
 def pytest_addoption(parser: Parser) -> None:
+    def add_ini_option(
+        opt_type: (
+            Literal["string", "paths", "pathlist", "args", "linelist", "bool"] | None
+        ),
+    ) -> None:
+        parser.addini(
+            group.options[-1].names()[0][2:],
+            group.options[-1].attrs()["help"],
+            opt_type,
+        )
+
     group = parser.getgroup("typeguard")
     group.addoption(
         "--typeguard-packages",
@@ -19,11 +32,15 @@ def pytest_addoption(parser: Parser) -> None:
         help="comma separated name list of packages and modules to instrument for "
         "type checking, or :all: to instrument all modules loaded after typeguard",
     )
+    add_ini_option("linelist")
+
     group.addoption(
         "--typeguard-debug-instrumentation",
         action="store_true",
         help="print all instrumented code to stderr",
     )
+    add_ini_option("bool")
+
     group.addoption(
         "--typeguard-typecheck-fail-callback",
         action="store",
@@ -33,6 +50,8 @@ def pytest_addoption(parser: Parser) -> None:
             "handle a TypeCheckError"
         ),
     )
+    add_ini_option("string")
+
     group.addoption(
         "--typeguard-forward-ref-policy",
         action="store",
@@ -42,21 +61,31 @@ def pytest_addoption(parser: Parser) -> None:
             "annotations"
         ),
     )
+    add_ini_option("string")
+
     group.addoption(
         "--typeguard-collection-check-strategy",
         action="store",
         choices=list(CollectionCheckStrategy.__members__),
         help="determines how thoroughly to check collections (list, dict, etc)",
     )
+    add_ini_option("string")
 
 
 def pytest_configure(config: Config) -> None:
-    packages_option = config.getoption("typeguard_packages")
-    if packages_option:
-        if packages_option == ":all:":
-            packages: list[str] | None = None
+    def getoption(name: str) -> Any:
+        return config.getoption(name.replace("-", "_")) or config.getini(name)
+
+    packages: list[str] | None = []
+    if packages_option := config.getoption("typeguard_packages"):
+        packages = [pkg.strip() for pkg in packages_option.split(",")]
+    elif packages_ini := config.getini("typeguard-packages"):
+        packages = packages_ini
+
+    if packages:
+        if packages == [":all:"]:
+            packages = None
         else:
-            packages = [pkg.strip() for pkg in packages_option.split(",")]
             already_imported_packages = sorted(
                 package for package in packages if package in sys.modules
             )
@@ -70,11 +99,11 @@ def pytest_configure(config: Config) -> None:
 
         install_import_hook(packages=packages)
 
-    debug_option = config.getoption("typeguard_debug_instrumentation")
+    debug_option = getoption("typeguard-debug-instrumentation")
     if debug_option:
         global_config.debug_instrumentation = True
 
-    fail_callback_option = config.getoption("typeguard_typecheck_fail_callback")
+    fail_callback_option = getoption("typeguard-typecheck-fail-callback")
     if fail_callback_option:
         callback = resolve_reference(fail_callback_option)
         if not callable(callback):
@@ -85,14 +114,12 @@ def pytest_configure(config: Config) -> None:
 
         global_config.typecheck_fail_callback = callback
 
-    forward_ref_policy_option = config.getoption("typeguard_forward_ref_policy")
+    forward_ref_policy_option = getoption("typeguard-forward-ref-policy")
     if forward_ref_policy_option:
         forward_ref_policy = ForwardRefPolicy.__members__[forward_ref_policy_option]
         global_config.forward_ref_policy = forward_ref_policy
 
-    collection_check_strategy_option = config.getoption(
-        "typeguard_collection_check_strategy"
-    )
+    collection_check_strategy_option = getoption("typeguard-collection-check-strategy")
     if collection_check_strategy_option:
         collection_check_strategy = CollectionCheckStrategy.__members__[
             collection_check_strategy_option

metaflow/_vendor/typeguard/_suppression.py

@@ -20,17 +20,15 @@ type_checks_suppress_lock = Lock()
 
 
 @overload
-def suppress_type_checks(func: Callable[P, T]) -> Callable[P, T]:
-    ...
+def suppress_type_checks(func: Callable[P, T]) -> Callable[P, T]: ...
 
 
 @overload
-def suppress_type_checks() -> ContextManager[None]:
-    ...
+def suppress_type_checks() -> ContextManager[None]: ...
 
 
 def suppress_type_checks(
-    func: Callable[P, T] | None = None
+    func: Callable[P, T] | None = None,
 ) -> Callable[P, T] | ContextManager[None]:
     """
     Temporarily suppress all type checking.

metaflow/_vendor/typeguard/_transformer.py

@@ -37,6 +37,7 @@ from ast import (
     Module,
     Mult,
     Name,
+    NamedExpr,
     NodeTransformer,
     NodeVisitor,
     Pass,
@@ -45,7 +46,6 @@ from ast import (
     RShift,
     Starred,
     Store,
-    Str,
     Sub,
     Subscript,
     Tuple,
@@ -65,9 +65,6 @@ from copy import deepcopy
 from dataclasses import dataclass, field
 from typing import Any, ClassVar, cast, overload
 
-if sys.version_info >= (3, 8):
-    from ast import NamedExpr
-
 generator_names = (
     "typing.Generator",
     "collections.abc.Generator",
@@ -159,13 +156,12 @@ class TransformMemo:
                 if isinstance(child, ImportFrom) and child.module == "__future__":
                     # (module only) __future__ imports must come first
                     continue
-                elif isinstance(child, Expr):
-                    if isinstance(child.value, Constant) and isinstance(
-                        child.value.value, str
-                    ):
-                        continue  # docstring
-                    elif sys.version_info < (3, 8) and isinstance(child.value, Str):
-                        continue  # docstring
+                elif (
+                    isinstance(child, Expr)
+                    and isinstance(child.value, Constant)
+                    and isinstance(child.value.value, str)
+                ):
+                    continue  # docstring
 
                 self.code_inject_index = index
                 break
@@ -349,15 +345,25 @@ class AnnotationTransformer(NodeTransformer):
     def __init__(self, transformer: TypeguardTransformer):
         self.transformer = transformer
         self._memo = transformer._memo
+        self._level = 0
 
     def visit(self, node: AST) -> Any:
+        # Don't process Literals
+        if isinstance(node, expr) and self._memo.name_matches(node, *literal_names):
+            return node
+
+        self._level += 1
         new_node = super().visit(node)
+        self._level -= 1
+
         if isinstance(new_node, Expression) and not hasattr(new_node, "body"):
             return None
 
         # Return None if this new node matches a variation of typing.Any
-        if isinstance(new_node, expr) and self._memo.name_matches(
-            new_node, *anytype_names
+        if (
+            self._level == 0
+            and isinstance(new_node, expr)
+            and self._memo.name_matches(new_node, *anytype_names)
         ):
             return None
 
@@ -367,10 +373,18 @@ class AnnotationTransformer(NodeTransformer):
         self.generic_visit(node)
 
         if isinstance(node.op, BitOr):
-            # If either side of the operation resolved to None, return None
+            # If either branch of the BinOp has been transformed to `None`, it means
+            # that a type in the union was ignored, so the entire annotation should e
+            # ignored
             if not hasattr(node, "left") or not hasattr(node, "right"):
                 return None
 
+            # Return Any if either side is Any
+            if self._memo.name_matches(node.left, *anytype_names):
+                return node.left
+            elif self._memo.name_matches(node.right, *anytype_names):
+                return node.right
+
             if sys.version_info < (3, 10):
                 union_name = self.transformer._get_import("typing", "Union")
                 return Subscript(
@@ -395,9 +409,9 @@ class AnnotationTransformer(NodeTransformer):
 
         # The subscript of typing(_extensions).Literal can be any arbitrary string, so
         # don't try to evaluate it as code
-        if not self._memo.name_matches(node.value, *literal_names) and node.slice:
+        if node.slice:
             if isinstance(node.slice, Index):
-                # Python 3.7 and 3.8
+                # Python 3.8
                 slice_value = node.slice.value  # type: ignore[attr-defined]
             else:
                 slice_value = node.slice
@@ -408,20 +422,22 @@ class AnnotationTransformer(NodeTransformer):
                     # forward reference
                     items = cast(
                         typing.List[expr],
-                        [self.generic_visit(slice_value.elts[0])]
-                        + slice_value.elts[1:],
+                        [self.visit(slice_value.elts[0])] + slice_value.elts[1:],
                     )
                 else:
                     items = cast(
                         typing.List[expr],
-                        [self.generic_visit(item) for item in slice_value.elts],
+                        [self.visit(item) for item in slice_value.elts],
                     )
 
                 # If this is a Union and any of the items is Any, erase the entire
                 # annotation
                 if self._memo.name_matches(node.value, "typing.Union") and any(
-                    isinstance(item, expr)
-                    and self._memo.name_matches(item, *anytype_names)
+                    item is None
+                    or (
+                        isinstance(item, expr)
+                        and self._memo.name_matches(item, *anytype_names)
+                    )
                     for item in items
                 ):
                     return None
@@ -441,9 +457,11 @@ class AnnotationTransformer(NodeTransformer):
                 # If the transformer erased the slice entirely, just return the node
                 # value without the subscript (unless it's Optional, in which case erase
                 # the node entirely
-                if self._memo.name_matches(node.value, "typing.Optional"):
+                if self._memo.name_matches(
+                    node.value, "typing.Optional"
+                ) and not hasattr(node, "slice"):
                     return None
-                elif sys.version_info >= (3, 9) and not hasattr(node, "slice"):
+                if sys.version_info >= (3, 9) and not hasattr(node, "slice"):
                     return node.value
                 elif sys.version_info < (3, 9) and not hasattr(node.slice, "value"):
                     return node.value
@@ -477,15 +495,6 @@ class AnnotationTransformer(NodeTransformer):
 
         return node
 
-    def visit_Str(self, node: Str) -> Any:
-        # Only used on Python 3.7
-        expression = ast.parse(node.s, mode="eval")
-        new_node = self.visit(expression)
-        if new_node:
-            return copy_location(new_node.body, node)
-        else:
-            return None
-
 
 class TypeguardTransformer(NodeTransformer):
     def __init__(
@@ -497,11 +506,32 @@ class TypeguardTransformer(NodeTransformer):
         self.target_node: FunctionDef | AsyncFunctionDef | None = None
         self.target_lineno = target_lineno
 
+    def generic_visit(self, node: AST) -> AST:
+        has_non_empty_body_initially = bool(getattr(node, "body", None))
+        initial_type = type(node)
+
+        node = super().generic_visit(node)
+
+        if (
+            type(node) is initial_type
+            and has_non_empty_body_initially
+            and hasattr(node, "body")
+            and not node.body
+        ):
+            # If we have still the same node type after transformation
+            # but we've optimised it's body away, we add a `pass` statement.
+            node.body = [Pass()]
+
+        return node
+
     @contextmanager
     def _use_memo(
         self, node: ClassDef | FunctionDef | AsyncFunctionDef
     ) -> Generator[None, Any, None]:
         new_memo = TransformMemo(node, self._memo, self._memo.path + (node.name,))
+        old_memo = self._memo
+        self._memo = new_memo
+
         if isinstance(node, (FunctionDef, AsyncFunctionDef)):
             new_memo.should_instrument = (
                 self._target_path is None or new_memo.path == self._target_path
@@ -553,8 +583,6 @@ class TypeguardTransformer(NodeTransformer):
         if isinstance(node, AsyncFunctionDef):
             new_memo.is_async = True
 
-        old_memo = self._memo
-        self._memo = new_memo
         yield
         self._memo = old_memo
 
@@ -563,12 +591,10 @@ class TypeguardTransformer(NodeTransformer):
         return memo.get_import(module, name)
 
     @overload
-    def _convert_annotation(self, annotation: None) -> None:
-        ...
+    def _convert_annotation(self, annotation: None) -> None: ...
 
     @overload
-    def _convert_annotation(self, annotation: expr) -> expr:
-        ...
+    def _convert_annotation(self, annotation: expr) -> expr: ...
 
     def _convert_annotation(self, annotation: expr | None) -> expr | None:
         if annotation is None:
@@ -591,8 +617,9 @@ class TypeguardTransformer(NodeTransformer):
         return node
 
     def visit_Module(self, node: Module) -> Module:
+        self._module_memo = self._memo = TransformMemo(node, None, ())
         self.generic_visit(node)
-        self._memo.insert_imports(node)
+        self._module_memo.insert_imports(node)
 
         fix_missing_locations(node)
         return node
@@ -691,14 +718,12 @@ class TypeguardTransformer(NodeTransformer):
                 if self.target_lineno == first_lineno:
                     assert self.target_node is None
                     self.target_node = node
-                    if node.decorator_list and sys.version_info >= (3, 8):
+                    if node.decorator_list:
                         self.target_lineno = node.decorator_list[0].lineno
                     else:
                         self.target_lineno = node.lineno
 
-                all_args = node.args.args + node.args.kwonlyargs
-                if sys.version_info >= (3, 8):
-                    all_args.extend(node.args.posonlyargs)
+                all_args = node.args.args + node.args.kwonlyargs + node.args.posonlyargs
 
                 # Ensure that any type shadowed by the positional or keyword-only
                 # argument names are ignored in this function
@@ -895,6 +920,22 @@ class TypeguardTransformer(NodeTransformer):
 
                 self._memo.insert_imports(node)
 
+                # Special case the __new__() method to create a local alias from the
+                # class name to the first argument (usually "cls")
+                if (
+                    isinstance(node, FunctionDef)
+                    and node.args
+                    and self._memo.parent is not None
+                    and isinstance(self._memo.parent.node, ClassDef)
+                    and node.name == "__new__"
+                ):
+                    first_args_expr = Name(node.args.args[0].arg, ctx=Load())
+                    cls_name = Name(self._memo.parent.node.name, ctx=Store())
+                    node.body.insert(
+                        self._memo.code_inject_index,
+                        Assign([cls_name], first_args_expr),
+                    )
+
                 # Rmove any placeholder "pass" at the end
                 if isinstance(node.body[-1], Pass):
                     del node.body[-1]
@@ -1176,11 +1217,6 @@ class TypeguardTransformer(NodeTransformer):
         """
         self.generic_visit(node)
 
-        # Fix empty node body (caused by removal of classes/functions not on the target
-        # path)
-        if not node.body:
-            node.body.append(Pass())
-
         if (
             self._memo is self._module_memo
             and isinstance(node.test, Name)

metaflow/_vendor/typeguard/_union_transformer.py

@@ -2,6 +2,7 @@
 Transforms lazily evaluated PEP 604 unions into typing.Unions, for compatibility with
 Python versions older than 3.10.
 """
+
 from __future__ import annotations
 
 from ast import (

metaflow/_vendor/typeguard/_utils.py

@@ -5,17 +5,27 @@ import sys
 from importlib import import_module
 from inspect import currentframe
 from types import CodeType, FrameType, FunctionType
-from typing import TYPE_CHECKING, Any, Callable, ForwardRef, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, ForwardRef, Union, cast, final
 from weakref import WeakValueDictionary
 
 if TYPE_CHECKING:
     from ._memo import TypeCheckMemo
 
-if sys.version_info >= (3, 10):
+if sys.version_info >= (3, 13):
     from typing import get_args, get_origin
 
     def evaluate_forwardref(forwardref: ForwardRef, memo: TypeCheckMemo) -> Any:
-        return forwardref._evaluate(memo.globals, memo.locals, frozenset())
+        return forwardref._evaluate(
+            memo.globals, memo.locals, type_params=(), recursive_guard=frozenset()
+        )
+
+elif sys.version_info >= (3, 10):
+    from typing import get_args, get_origin
+
+    def evaluate_forwardref(forwardref: ForwardRef, memo: TypeCheckMemo) -> Any:
+        return forwardref._evaluate(
+            memo.globals, memo.locals, recursive_guard=frozenset()
+        )
 
 else:
     from metaflow._vendor.typing_extensions import get_args, get_origin
@@ -47,12 +57,6 @@ else:
             raise
 
 
-if sys.version_info >= (3, 8):
-    from typing import final
-else:
-    from metaflow._vendor.typing_extensions import final
-
-
 _functions_map: WeakValueDictionary[CodeType, FunctionType] = WeakValueDictionary()