prefect-client 2.19.3__tar.gz → 2.19.5__tar.gz

{prefect-client-2.19.3/src/prefect_client.egg-info → prefect-client-2.19.5}/PKG-INFO

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

{prefect-client-2.19.3 → prefect-client-2.19.5}/src/prefect/client/schemas/actions.py

@@ -778,7 +778,7 @@ class GlobalConcurrencyLimitUpdate(ActionBaseModel):
 
     name: Optional[str] = Field(None)
     limit: Optional[NonNegativeInteger] = Field(None)
-    active: Optional[NonNegativeInteger] = Field(None)
+    active: Optional[bool] = Field(None)
     active_slots: Optional[NonNegativeInteger] = Field(None)
     slot_decay_per_second: Optional[NonNegativeFloat] = Field(None)
 

{prefect-client-2.19.3 → prefect-client-2.19.5}/src/prefect/deployments/base.py

@@ -396,7 +396,13 @@ async def _find_flow_functions_in_file(filename: str) -> List[Dict]:
             return decorated_functions
 
     for node in ast.walk(tree):
-        if isinstance(node, ast.FunctionDef):
+        if isinstance(
+            node,
+            (
+                ast.FunctionDef,
+                ast.AsyncFunctionDef,
+            ),
+        ):
             for decorator in node.decorator_list:
                 # handles @flow
                 is_name_match = (

{prefect-client-2.19.3 → prefect-client-2.19.5}/src/prefect/flows.py

@@ -106,7 +106,7 @@ from prefect.utilities.callables import (
 )
 from prefect.utilities.collections import listrepr
 from prefect.utilities.hashing import file_hash
-from prefect.utilities.importtools import import_object
+from prefect.utilities.importtools import import_object, safe_load_namespace
 from prefect.utilities.visualization import (
     FlowVisualizationError,
     GraphvizExecutableNotFoundError,
@@ -1830,7 +1830,14 @@ def load_flow_argument_from_entrypoint(
         (
             node
             for node in ast.walk(parsed_code)
-            if isinstance(node, ast.FunctionDef) and node.name == func_name
+            if isinstance(
+                node,
+                (
+                    ast.FunctionDef,
+                    ast.AsyncFunctionDef,
+                ),
+            )
+            and node.name == func_name
         ),
         None,
     )
@@ -1843,11 +1850,33 @@ def load_flow_argument_from_entrypoint(
         ):
             for keyword in decorator.keywords:
                 if keyword.arg == arg:
-                    return (
-                        keyword.value.value
-                    )  # Return the string value of the argument
+                    if isinstance(keyword.value, ast.Constant):
+                        return (
+                            keyword.value.value
+                        )  # Return the string value of the argument
+
+                    # 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)
+                    literal_arg_value = ast.get_source_segment(
+                        source_code, keyword.value
+                    )
+                    try:
+                        evaluated_value = eval(literal_arg_value, namespace)  # type: ignore
+                    except Exception as e:
+                        logger.info(
+                            "Failed to parse @flow argument: `%s=%s` due to the following error. Ignoring and falling back to default behavior.",
+                            arg,
+                            literal_arg_value,
+                            exc_info=e,
+                        )
+                        # ignore the decorator arg and fallback to default behavior
+                        break
+                    return str(evaluated_value)
 
     if arg == "name":
         return func_name.replace(
             "_", "-"
         )  # If no matching decorator or keyword argument is found
+
+    return None

{prefect-client-2.19.3 → prefect-client-2.19.5}/src/prefect/infrastructure/container.py

@@ -124,6 +124,12 @@ class BaseDockerLogin(Block, ABC):
 )
 class DockerRegistry(BaseDockerLogin):
     """
+    DEPRECATION WARNING:
+
+    This class is deprecated as of March 2024 and will not be available after September 2024.
+    It has been replaced by `DockerRegistryCredentials` from the `prefect-docker` package, which
+    offers enhanced functionality and better a better user experience.
+
     Connects to a Docker registry.
 
     Requires a Docker Engine to be connectable.

{prefect-client-2.19.3 → prefect-client-2.19.5}/src/prefect/utilities/callables.py

@@ -448,7 +448,14 @@ def _generate_signature_from_source(
         (
             node
             for node in ast.walk(parsed_code)
-            if isinstance(node, ast.FunctionDef) and node.name == func_name
+            if isinstance(
+                node,
+                (
+                    ast.FunctionDef,
+                    ast.AsyncFunctionDef,
+                ),
+            )
+            and node.name == func_name
         ),
         None,
     )
@@ -456,6 +463,26 @@ def _generate_signature_from_source(
         raise ValueError(f"Function {func_name} not found in source code")
     parameters = []
 
+    # Handle annotations for positional only args e.g. def func(a, /, b, c)
+    for arg in func_def.args.posonlyargs:
+        name = arg.arg
+        annotation = arg.annotation
+        if annotation is not None:
+            try:
+                ann_code = compile(ast.Expression(annotation), "<string>", "eval")
+                annotation = eval(ann_code, namespace)
+            except Exception as e:
+                logger.debug("Failed to evaluate annotation for %s: %s", name, e)
+                annotation = inspect.Parameter.empty
+        else:
+            annotation = inspect.Parameter.empty
+
+        param = inspect.Parameter(
+            name, inspect.Parameter.POSITIONAL_ONLY, annotation=annotation
+        )
+        parameters.append(param)
+
+    # Determine the annotations for args e.g. def func(a: int, b: str, c: float)
     for arg in func_def.args.args:
         name = arg.arg
         annotation = arg.annotation
@@ -478,6 +505,7 @@ def _generate_signature_from_source(
         )
         parameters.append(param)
 
+    # Handle default values for args e.g. def func(a=1, b="hello", c=3.14)
     defaults = [None] * (
         len(func_def.args.args) - len(func_def.args.defaults)
     ) + func_def.args.defaults
@@ -493,6 +521,42 @@ def _generate_signature_from_source(
                 default = None  # Set to None if evaluation fails
             parameters[parameters.index(param)] = param.replace(default=default)
 
+    # Handle annotations for keyword only args e.g. def func(*, a: int, b: str)
+    for kwarg in func_def.args.kwonlyargs:
+        name = kwarg.arg
+        annotation = kwarg.annotation
+        if annotation is not None:
+            try:
+                ann_code = compile(ast.Expression(annotation), "<string>", "eval")
+                annotation = eval(ann_code, namespace)
+            except Exception as e:
+                logger.debug("Failed to evaluate annotation for %s: %s", name, e)
+                annotation = inspect.Parameter.empty
+        else:
+            annotation = inspect.Parameter.empty
+
+        param = inspect.Parameter(
+            name, inspect.Parameter.KEYWORD_ONLY, annotation=annotation
+        )
+        parameters.append(param)
+
+    # Handle default values for keyword only args e.g. def func(*, a=1, b="hello")
+    defaults = [None] * (
+        len(func_def.args.kwonlyargs) - len(func_def.args.kw_defaults)
+    ) + func_def.args.kw_defaults
+    for param, default in zip(parameters[-len(func_def.args.kwonlyargs) :], defaults):
+        if default is not None:
+            try:
+                def_code = compile(ast.Expression(default), "<string>", "eval")
+                default = eval(def_code, namespace)
+            except Exception as e:
+                logger.debug(
+                    "Failed to evaluate default value for %s: %s", param.name, e
+                )
+                default = None
+            parameters[parameters.index(param)] = param.replace(default=default)
+
+    # Handle annotations for varargs and kwargs e.g. def func(*args: int, **kwargs: str)
     if func_def.args.vararg:
         parameters.append(
             inspect.Parameter(
@@ -504,7 +568,7 @@ def _generate_signature_from_source(
             inspect.Parameter(func_def.args.kwarg.arg, inspect.Parameter.VAR_KEYWORD)
         )
 
-    # Handle return annotation
+    # Handle return annotation e.g. def func() -> int
     return_annotation = func_def.returns
     if return_annotation is not None:
         try:
@@ -536,7 +600,14 @@ def _get_docstring_from_source(source_code: str, func_name: str) -> Optional[str
         (
             node
             for node in ast.walk(parsed_code)
-            if isinstance(node, ast.FunctionDef) and node.name == func_name
+            if isinstance(
+                node,
+                (
+                    ast.FunctionDef,
+                    ast.AsyncFunctionDef,
+                ),
+            )
+            and node.name == func_name
         ),
         None,
     )

{prefect-client-2.19.3 → prefect-client-2.19.5}/src/prefect/utilities/importtools.py

@@ -379,7 +379,16 @@ def safe_load_namespace(source_code: str):
     """
     parsed_code = ast.parse(source_code)
 
-    namespace = {}
+    namespace = {"__name__": "prefect_safe_namespace_loader"}
+
+    # Remove the body of the if __name__ == "__main__": block from the AST to prevent
+    # execution of guarded code
+    new_body = []
+    for node in parsed_code.body:
+        if _is_main_block(node):
+            continue
+        new_body.append(node)
+    parsed_code.body = new_body
 
     # Walk through the AST and find all import statements
     for node in ast.walk(parsed_code):
@@ -413,11 +422,11 @@ def safe_load_namespace(source_code: str):
             except ImportError as e:
                 logger.debug("Failed to import from %s: %s", node.module, e)
 
-    # Handle local class definitions
+    # Handle local definitions
     for node in ast.walk(parsed_code):
-        if isinstance(node, (ast.ClassDef, ast.FunctionDef)):
+        if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.Assign)):
             try:
-                # Compile and execute each class and function definition locally
+                # Compile and execute each class and function definition and assignment
                 code = compile(
                     ast.Module(body=[node], type_ignores=[]),
                     filename="<ast>",
@@ -425,5 +434,25 @@ def safe_load_namespace(source_code: str):
                 )
                 exec(code, namespace)
             except Exception as e:
-                logger.debug("Failed to compile class definition: %s", e)
+                logger.debug("Failed to compile: %s", e)
     return namespace
+
+
+def _is_main_block(node: ast.AST):
+    """
+    Check if the node is an `if __name__ == "__main__":` block.
+    """
+    if isinstance(node, ast.If):
+        try:
+            # Check if the condition is `if __name__ == "__main__":`
+            if (
+                isinstance(node.test, ast.Compare)
+                and isinstance(node.test.left, ast.Name)
+                and node.test.left.id == "__name__"
+                and isinstance(node.test.comparators[0], ast.Constant)
+                and node.test.comparators[0].value == "__main__"
+            ):
+                return True
+        except AttributeError:
+            pass
+    return False

{prefect-client-2.19.3 → prefect-client-2.19.5/src/prefect_client.egg-info}/PKG-INFO

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