ob-metaflow-stubs 2.11.4.1__py2.py3-none-any.whl

metaflow-stubs/__init__.pyi

@@ -0,0 +1,2753 @@
+##################################################################################
+#                       Auto-generated Metaflow stub file                        #
+# MF version: 2.11.4.1                                                           #
+# Generated on 2024-02-28T05:30:43.887672                                        #
+##################################################################################
+
+from __future__ import annotations
+
+import typing
+if typing.TYPE_CHECKING:
+    import metaflow.plugins.datatools.s3.s3
+    import metaflow.metaflow_current
+    import io
+    import metaflow.client.core
+    import metaflow.parameters
+    import metaflow.datastore.inputs
+    import metaflow._vendor.click.types
+    import datetime
+    import metaflow.events
+    import typing
+FlowSpecDerived = typing.TypeVar("FlowSpecDerived", bound="FlowSpec", contravariant=False, covariant=False)
+StepFlag = typing.NewType("StepFlag", bool)
+
+CURRENT_DIRECTORY: str
+
+INFO_FILE: str
+
+EXT_PKG: str
+
+def parallel_imap_unordered(func: typing.Callable[[typing.Any], typing.Any], iterable: typing.Iterable[typing.Any], max_parallel: typing.Optional[int] = None, dir: typing.Optional[str] = None) -> typing.Iterator[typing.Any]:
+    """
+    Parallelizes execution of a function using multiprocessing. The result
+    order is not guaranteed.
+    
+    Parameters
+    ----------
+    func : Callable[[Any], Any]
+        Function taking a single argument and returning a result
+    iterable : Iterable[Any]
+        Iterable over arguments to pass to fun
+    max_parallel int, optional, default None
+        Maximum parallelism. If not specified, uses the number of CPUs
+    dir : str, optional, default None
+        If specified, directory where temporary files are created
+    
+    Yields
+    ------
+    Any
+        One result from calling func on one argument
+    """
+    ...
+
+def parallel_map(func: typing.Callable[[typing.Any], typing.Any], iterable: typing.Iterable[typing.Any], max_parallel: typing.Optional[int] = None, dir: typing.Optional[str] = None) -> typing.List[typing.Any]:
+    """
+    Parallelizes execution of a function using multiprocessing. The result
+    order is that of the arguments in `iterable`
+    
+    Parameters
+    ----------
+    func : Callable[[Any], Any]
+        Function taking a single argument and returning a result
+    iterable : Iterable[Any]
+        Iterable over arguments to pass to fun
+    max_parallel int, optional, default None
+        Maximum parallelism. If not specified, uses the number of CPUs
+    dir : str, optional, default None
+        If specified, directory where temporary files are created
+    
+    Returns
+    -------
+    List[Any]
+        Results. The items in the list are in the same order as the items
+        in `iterable`.
+    """
+    ...
+
+current: metaflow.metaflow_current.Current
+
+def metadata(ms: str) -> str:
+    """
+    Switch Metadata provider.
+    
+    This call has a global effect. Selecting the local metadata will,
+    for example, not allow access to information stored in remote
+    metadata providers.
+    
+    Note that you don't typically have to call this function directly. Usually
+    the metadata provider is set through the Metaflow configuration file. If you
+    need to switch between multiple providers, you can use the `METAFLOW_PROFILE`
+    environment variable to switch between configurations.
+    
+    Parameters
+    ----------
+    ms : str
+        Can be a path (selects local metadata), a URL starting with http (selects
+        the service metadata) or an explicit specification <metadata_type>@<info>; as an
+        example, you can specify local@<path> or service@<url>.
+    
+    Returns
+    -------
+    str
+        The description of the metadata selected (equivalent to the result of
+        get_metadata()).
+    """
+    ...
+
+class FlowSpec(object, metaclass=type):
+    def __init__(self, use_cli = True):
+        """
+        Construct a FlowSpec
+        
+        Parameters
+        ----------
+        use_cli : bool, default True
+            Set to True if the flow is invoked from __main__ or the command line
+        """
+        ...
+    @property
+    def script_name(self) -> str:
+        """
+        [Legacy function - do not use. Use `current` instead]
+        
+        Returns the name of the script containing the flow
+        
+        Returns
+        -------
+        str
+            A string containing the name of the script
+        """
+        ...
+    def __iter__(self):
+        """
+        [Legacy function - do not use]
+        
+        Iterate over all steps in the Flow
+        
+        Returns
+        -------
+        Iterator[graph.DAGNode]
+            Iterator over the steps in the flow
+        """
+        ...
+    def __getattr__(self, name: str):
+        ...
+    def cmd(self, cmdline, input = {}, output = []):
+        """
+        [Legacy function - do not use]
+        """
+        ...
+    @property
+    def index(self) -> typing.Optional[int]:
+        """
+        The index of this foreach branch.
+        
+        In a foreach step, multiple instances of this step (tasks) will be executed,
+        one for each element in the foreach. This property returns the zero based index
+        of the current task. If this is not a foreach step, this returns None.
+        
+        If you need to know the indices of the parent tasks in a nested foreach, use
+        `FlowSpec.foreach_stack`.
+        
+        Returns
+        -------
+        int, optional
+            Index of the task in a foreach step.
+        """
+        ...
+    @property
+    def input(self) -> typing.Optional[typing.Any]:
+        """
+        The value of the foreach artifact in this foreach branch.
+        
+        In a foreach step, multiple instances of this step (tasks) will be executed,
+        one for each element in the foreach. This property returns the element passed
+        to the current task. If this is not a foreach step, this returns None.
+        
+        If you need to know the values of the parent tasks in a nested foreach, use
+        `FlowSpec.foreach_stack`.
+        
+        Returns
+        -------
+        object, optional
+            Input passed to the foreach task.
+        """
+        ...
+    def foreach_stack(self) -> typing.Optional[typing.List[typing.Tuple[int, int, typing.Any]]]:
+        """
+        Returns the current stack of foreach indexes and values for the current step.
+        
+        Use this information to understand what data is being processed in the current
+        foreach branch. For example, considering the following code:
+        ```
+        @step
+        def root(self):
+            self.split_1 = ['a', 'b', 'c']
+            self.next(self.nest_1, foreach='split_1')
+        
+        @step
+        def nest_1(self):
+            self.split_2 = ['d', 'e', 'f', 'g']
+            self.next(self.nest_2, foreach='split_2'):
+        
+        @step
+        def nest_2(self):
+            foo = self.foreach_stack()
+        ```
+        
+        `foo` will take the following values in the various tasks for nest_2:
+        ```
+            [(0, 3, 'a'), (0, 4, 'd')]
+            [(0, 3, 'a'), (1, 4, 'e')]
+            ...
+            [(0, 3, 'a'), (3, 4, 'g')]
+            [(1, 3, 'b'), (0, 4, 'd')]
+            ...
+        ```
+        where each tuple corresponds to:
+        
+        - The index of the task for that level of the loop.
+        - The number of splits for that level of the loop.
+        - The value for that level of the loop.
+        
+        Note that the last tuple returned in a task corresponds to:
+        
+        - 1st element: value returned by `self.index`.
+        - 3rd element: value returned by `self.input`.
+        
+        Returns
+        -------
+        List[Tuple[int, int, Any]]
+            An array describing the current stack of foreach steps.
+        """
+        ...
+    def merge_artifacts(self, inputs: metaflow.datastore.inputs.Inputs, exclude: typing.Optional[typing.List[str]] = None, include: typing.Optional[typing.List[str]] = None):
+        """
+        Helper function for merging artifacts in a join step.
+        
+        This function takes all the artifacts coming from the branches of a
+        join point and assigns them to self in the calling step. Only artifacts
+        not set in the current step are considered. If, for a given artifact, different
+        values are present on the incoming edges, an error will be thrown and the artifacts
+        that conflict will be reported.
+        
+        As a few examples, in the simple graph: A splitting into B and C and joining in D:
+        ```
+        A:
+          self.x = 5
+          self.y = 6
+        B:
+          self.b_var = 1
+          self.x = from_b
+        C:
+          self.x = from_c
+        
+        D:
+          merge_artifacts(inputs)
+        ```
+        In D, the following artifacts are set:
+          - `y` (value: 6), `b_var` (value: 1)
+          - if `from_b` and `from_c` are the same, `x` will be accessible and have value `from_b`
+          - if `from_b` and `from_c` are different, an error will be thrown. To prevent this error,
+            you need to manually set `self.x` in D to a merged value (for example the max) prior to
+            calling `merge_artifacts`.
+        
+        Parameters
+        ----------
+        inputs : Inputs
+            Incoming steps to the join point.
+        exclude : List[str], optional, default None
+            If specified, do not consider merging artifacts with a name in `exclude`.
+            Cannot specify if `include` is also specified.
+        include : List[str], optional, default None
+            If specified, only merge artifacts specified. Cannot specify if `exclude` is
+            also specified.
+        
+        Raises
+        ------
+        MetaflowException
+            This exception is thrown if this is not called in a join step.
+        UnhandledInMergeArtifactsException
+            This exception is thrown in case of unresolved conflicts.
+        MissingInMergeArtifactsException
+            This exception is thrown in case an artifact specified in `include` cannot
+            be found.
+        """
+        ...
+    def next(self, *dsts: typing.Callable[..., None], **kwargs):
+        """
+        Indicates the next step to execute after this step has completed.
+        
+        This statement should appear as the last statement of each step, except
+        the end step.
+        
+        There are several valid formats to specify the next step:
+        
+        - Straight-line connection: `self.next(self.next_step)` where `next_step` is a method in
+          the current class decorated with the `@step` decorator.
+        
+        - Static fan-out connection: `self.next(self.step1, self.step2, ...)` where `stepX` are
+          methods in the current class decorated with the `@step` decorator.
+        
+        - Foreach branch:
+          ```
+          self.next(self.foreach_step, foreach='foreach_iterator')
+          ```
+          In this situation, `foreach_step` is a method in the current class decorated with the
+          `@step` decorator and `foreach_iterator` is a variable name in the current class that
+          evaluates to an iterator. A task will be launched for each value in the iterator and
+          each task will execute the code specified by the step `foreach_step`.
+        
+        Parameters
+        ----------
+        dsts : Callable[..., None]
+            One or more methods annotated with `@step`.
+        
+        Raises
+        ------
+        InvalidNextException
+            Raised if the format of the arguments does not match one of the ones given above.
+        """
+        ...
+    def __str__(self):
+        ...
+    def __getstate__(self):
+        ...
+    ...
+
+class Parameter(object, metaclass=type):
+    def __init__(self, name: str, default: typing.Union[str, float, int, bool, typing.Dict[str, typing.Any], typing.Callable[[], typing.Union[str, float, int, bool, typing.Dict[str, typing.Any]]], None] = None, type: typing.Union[typing.Type[str], typing.Type[float], typing.Type[int], typing.Type[bool], metaflow.parameters.JSONTypeClass, None] = None, help: typing.Optional[str] = None, required: bool = False, show_default: bool = True, **kwargs: typing.Dict[str, typing.Any]):
+        ...
+    def __repr__(self):
+        ...
+    def __str__(self):
+        ...
+    def option_kwargs(self, deploy_mode):
+        ...
+    def load_parameter(self, v):
+        ...
+    @property
+    def is_string_type(self):
+        ...
+    def __getitem__(self, x):
+        ...
+    ...
+
+class JSONTypeClass(metaflow._vendor.click.types.ParamType, metaclass=type):
+    def convert(self, value, param, ctx):
+        ...
+    def __str__(self):
+        ...
+    def __repr__(self):
+        ...
+    ...
+
+JSONType: metaflow.parameters.JSONTypeClass
+
+class S3(object, metaclass=type):
+    @classmethod
+    def get_root_from_config(cls, echo, create_on_absent = True):
+        ...
+    def __enter__(self) -> metaflow.plugins.datatools.s3.s3.S3:
+        ...
+    def __exit__(self, *args):
+        ...
+    def close(self):
+        """
+        Delete all temporary files downloaded in this context.
+        """
+        ...
+    def list_paths(self, keys: typing.Optional[typing.Iterable[str]] = None) -> typing.List[metaflow.plugins.datatools.s3.s3.S3Object]:
+        """
+        List the next level of paths in S3.
+        
+        If multiple keys are specified, listings are done in parallel. The returned
+        S3Objects have `.exists == False` if the path refers to a prefix, not an
+        existing S3 object.
+        
+        For instance, if the directory hierarchy is
+        ```
+        a/0.txt
+        a/b/1.txt
+        a/c/2.txt
+        a/d/e/3.txt
+        f/4.txt
+        ```
+        The `list_paths(['a', 'f'])` call returns
+        ```
+        a/0.txt (exists == True)
+        a/b/ (exists == False)
+        a/c/ (exists == False)
+        a/d/ (exists == False)
+        f/4.txt (exists == True)
+        ```
+        
+        Parameters
+        ----------
+        keys : Iterable[str], optional, default None
+            List of paths.
+        
+        Returns
+        -------
+        List[S3Object]
+            S3Objects under the given paths, including prefixes (directories) that
+            do not correspond to leaf objects.
+        """
+        ...
+    def list_recursive(self, keys: typing.Optional[typing.Iterable[str]] = None) -> typing.List[metaflow.plugins.datatools.s3.s3.S3Object]:
+        """
+        List all objects recursively under the given prefixes.
+        
+        If multiple keys are specified, listings are done in parallel. All objects
+        returned have `.exists == True` as this call always returns leaf objects.
+        
+        For instance, if the directory hierarchy is
+        ```
+        a/0.txt
+        a/b/1.txt
+        a/c/2.txt
+        a/d/e/3.txt
+        f/4.txt
+        ```
+        The `list_paths(['a', 'f'])` call returns
+        ```
+        a/0.txt (exists == True)
+        a/b/1.txt (exists == True)
+        a/c/2.txt (exists == True)
+        a/d/e/3.txt (exists == True)
+        f/4.txt (exists == True)
+        ```
+        
+        Parameters
+        ----------
+        keys : Iterable[str], optional, default None
+            List of paths.
+        
+        Returns
+        -------
+        List[S3Object]
+            S3Objects under the given paths.
+        """
+        ...
+    def info(self, key: typing.Optional[str] = None, return_missing: bool = False) -> metaflow.plugins.datatools.s3.s3.S3Object:
+        """
+        Get metadata about a single object in S3.
+        
+        This call makes a single `HEAD` request to S3 which can be
+        much faster than downloading all data with `get`.
+        
+        Parameters
+        ----------
+        key : str, optional, default None
+            Object to query. It can be an S3 url or a path suffix.
+        return_missing : bool, default False
+            If set to True, do not raise an exception for a missing key but
+            return it as an `S3Object` with `.exists == False`.
+        
+        Returns
+        -------
+        S3Object
+            An S3Object corresponding to the object requested. The object
+            will have `.downloaded == False`.
+        """
+        ...
+    def info_many(self, keys: typing.Iterable[str], return_missing: bool = False) -> typing.List[metaflow.plugins.datatools.s3.s3.S3Object]:
+        """
+        Get metadata about many objects in S3 in parallel.
+        
+        This call makes a single `HEAD` request to S3 which can be
+        much faster than downloading all data with `get`.
+        
+        Parameters
+        ----------
+        keys : Iterable[str]
+            Objects to query. Each key can be an S3 url or a path suffix.
+        return_missing : bool, default False
+            If set to True, do not raise an exception for a missing key but
+            return it as an `S3Object` with `.exists == False`.
+        
+        Returns
+        -------
+        List[S3Object]
+            A list of S3Objects corresponding to the paths requested. The
+            objects will have `.downloaded == False`.
+        """
+        ...
+    def get(self, key: typing.Union[str, metaflow.plugins.datatools.s3.s3.S3GetObject, None] = None, return_missing: bool = False, return_info: bool = True) -> metaflow.plugins.datatools.s3.s3.S3Object:
+        """
+        Get a single object from S3.
+        
+        Parameters
+        ----------
+        key : Union[str, S3GetObject], optional, default None
+            Object to download. It can be an S3 url, a path suffix, or
+            an S3GetObject that defines a range of data to download. If None, or
+            not provided, gets the S3 root.
+        return_missing : bool, default False
+            If set to True, do not raise an exception for a missing key but
+            return it as an `S3Object` with `.exists == False`.
+        return_info : bool, default True
+            If set to True, fetch the content-type and user metadata associated
+            with the object at no extra cost, included for symmetry with `get_many`
+        
+        Returns
+        -------
+        S3Object
+            An S3Object corresponding to the object requested.
+        """
+        ...
+    def get_many(self, keys: typing.Iterable[typing.Union[str, metaflow.plugins.datatools.s3.s3.S3GetObject]], return_missing: bool = False, return_info: bool = True) -> typing.List[metaflow.plugins.datatools.s3.s3.S3Object]:
+        """
+        Get many objects from S3 in parallel.
+        
+        Parameters
+        ----------
+        keys : Iterable[Union[str, S3GetObject]]
+            Objects to download. Each object can be an S3 url, a path suffix, or
+            an S3GetObject that defines a range of data to download.
+        return_missing : bool, default False
+            If set to True, do not raise an exception for a missing key but
+            return it as an `S3Object` with `.exists == False`.
+        return_info : bool, default True
+            If set to True, fetch the content-type and user metadata associated
+            with the object at no extra cost, included for symmetry with `get_many`.
+        
+        Returns
+        -------
+        List[S3Object]
+            S3Objects corresponding to the objects requested.
+        """
+        ...
+    def get_recursive(self, keys: typing.Iterable[str], return_info: bool = False) -> typing.List[metaflow.plugins.datatools.s3.s3.S3Object]:
+        """
+        Get many objects from S3 recursively in parallel.
+        
+        Parameters
+        ----------
+        keys : Iterable[str]
+            Prefixes to download recursively. Each prefix can be an S3 url or a path suffix
+            which define the root prefix under which all objects are downloaded.
+        return_info : bool, default False
+            If set to True, fetch the content-type and user metadata associated
+            with the object.
+        
+        Returns
+        -------
+        List[S3Object]
+            S3Objects stored under the given prefixes.
+        """
+        ...
+    def get_all(self, return_info: bool = False) -> typing.List[metaflow.plugins.datatools.s3.s3.S3Object]:
+        """
+        Get all objects under the prefix set in the `S3` constructor.
+        
+        This method requires that the `S3` object is initialized either with `run` or
+        `s3root`.
+        
+        Parameters
+        ----------
+        return_info : bool, default False
+            If set to True, fetch the content-type and user metadata associated
+            with the object.
+        
+        Returns
+        -------
+        Iterable[S3Object]
+            S3Objects stored under the main prefix.
+        """
+        ...
+    def put(self, key: typing.Union[str, metaflow.plugins.datatools.s3.s3.S3PutObject], obj: typing.Union[io.RawIOBase, io.BufferedIOBase, str, bytes], overwrite: bool = True, content_type: typing.Optional[str] = None, metadata: typing.Optional[typing.Dict[str, str]] = None) -> str:
+        """
+        Upload a single object to S3.
+        
+        Parameters
+        ----------
+        key : Union[str, S3PutObject]
+            Object path. It can be an S3 url or a path suffix.
+        obj : PutValue
+            An object to store in S3. Strings are converted to UTF-8 encoding.
+        overwrite : bool, default True
+            Overwrite the object if it exists. If set to False, the operation
+            succeeds without uploading anything if the key already exists.
+        content_type : str, optional, default None
+            Optional MIME type for the object.
+        metadata : Dict[str, str], optional, default None
+            A JSON-encodable dictionary of additional headers to be stored
+            as metadata with the object.
+        
+        Returns
+        -------
+        str
+            URL of the object stored.
+        """
+        ...
+    def put_many(self, key_objs: typing.List[typing.Union[typing.Tuple[str, typing.Union[io.RawIOBase, io.BufferedIOBase, str, bytes]], metaflow.plugins.datatools.s3.s3.S3PutObject]], overwrite: bool = True) -> typing.List[typing.Tuple[str, str]]:
+        """
+        Upload many objects to S3.
+        
+        Each object to be uploaded can be specified in two ways:
+        
+        1. As a `(key, obj)` tuple where `key` is a string specifying
+           the path and `obj` is a string or a bytes object.
+        
+        2. As a `S3PutObject` which contains additional metadata to be
+           stored with the object.
+        
+        Parameters
+        ----------
+        key_objs : List[Union[Tuple[str, PutValue], S3PutObject]]
+            List of key-object pairs to upload.
+        overwrite : bool, default True
+            Overwrite the object if it exists. If set to False, the operation
+            succeeds without uploading anything if the key already exists.
+        
+        Returns
+        -------
+        List[Tuple[str, str]]
+            List of `(key, url)` pairs corresponding to the objects uploaded.
+        """
+        ...
+    def put_files(self, key_paths: typing.List[typing.Union[typing.Tuple[str, typing.Union[io.RawIOBase, io.BufferedIOBase, str, bytes]], metaflow.plugins.datatools.s3.s3.S3PutObject]], overwrite: bool = True) -> typing.List[typing.Tuple[str, str]]:
+        """
+        Upload many local files to S3.
+        
+        Each file to be uploaded can be specified in two ways:
+        
+        1. As a `(key, path)` tuple where `key` is a string specifying
+           the S3 path and `path` is the path to a local file.
+        
+        2. As a `S3PutObject` which contains additional metadata to be
+           stored with the file.
+        
+        Parameters
+        ----------
+        key_paths :  List[Union[Tuple[str, PutValue], S3PutObject]]
+            List of files to upload.
+        overwrite : bool, default True
+            Overwrite the object if it exists. If set to False, the operation
+            succeeds without uploading anything if the key already exists.
+        
+        Returns
+        -------
+        List[Tuple[str, str]]
+            List of `(key, url)` pairs corresponding to the files uploaded.
+        """
+        ...
+    ...
+
+class IncludeFile(metaflow.parameters.Parameter, metaclass=type):
+    def __init__(self, name: str, required: bool = False, is_text: bool = True, encoding: str = "utf-8", help: typing.Optional[str] = None, **kwargs: typing.Dict[str, str]):
+        ...
+    def load_parameter(self, v):
+        ...
+    ...
+
+@typing.overload
+def step(f: typing.Callable[[FlowSpecDerived], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    """
+    Marks a method in a FlowSpec as a Metaflow Step. Note that this
+    decorator needs to be placed as close to the method as possible (ie:
+    before other decorators).
+    
+    In other words, this is valid:
+    ```
+    @batch
+    @step
+    def foo(self):
+        pass
+    ```
+    
+    whereas this is not:
+    ```
+    @step
+    @batch
+    def foo(self):
+        pass
+    ```
+    
+    Parameters
+    ----------
+    f : Union[Callable[[FlowSpecDerived], None], Callable[[FlowSpecDerived, Any], None]]
+        Function to make into a Metaflow Step
+    
+    Returns
+    -------
+    Union[Callable[[FlowSpecDerived, StepFlag], None], Callable[[FlowSpecDerived, Any, StepFlag], None]]
+        Function that is a Metaflow Step
+    """
+    ...
+
+@typing.overload
+def step(f: typing.Callable[[FlowSpecDerived, typing.Any], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def step(f: typing.Union[typing.Callable[[FlowSpecDerived], None], typing.Callable[[FlowSpecDerived, typing.Any], None]]):
+    """
+    Marks a method in a FlowSpec as a Metaflow Step. Note that this
+    decorator needs to be placed as close to the method as possible (ie:
+    before other decorators).
+    
+    In other words, this is valid:
+    ```
+    @batch
+    @step
+    def foo(self):
+        pass
+    ```
+    
+    whereas this is not:
+    ```
+    @step
+    @batch
+    def foo(self):
+        pass
+    ```
+    
+    Parameters
+    ----------
+    f : Union[Callable[[FlowSpecDerived], None], Callable[[FlowSpecDerived, Any], None]]
+        Function to make into a Metaflow Step
+    
+    Returns
+    -------
+    Union[Callable[[FlowSpecDerived, StepFlag], None], Callable[[FlowSpecDerived, Any, StepFlag], None]]
+        Function that is a Metaflow Step
+    """
+    ...
+
+@typing.overload
+def environment(*, vars: typing.Dict[str, str] = {}) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies environment variables to be set prior to the execution of a step.
+    
+    Parameters
+    ----------
+    vars : Dict[str, str], default {}
+        Dictionary of environment variables to set.
+    """
+    ...
+
+@typing.overload
+def environment(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def environment(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def environment(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, vars: typing.Dict[str, str] = {}):
+    """
+    Specifies environment variables to be set prior to the execution of a step.
+    
+    Parameters
+    ----------
+    vars : Dict[str, str], default {}
+        Dictionary of environment variables to set.
+    """
+    ...
+
+def kubernetes(*, cpu: int = 1, memory: int = 4096, disk: int = 10240, image: typing.Optional[str] = None, image_pull_policy: str = "KUBERNETES_IMAGE_PULL_POLICY", service_account: str = "METAFLOW_KUBERNETES_SERVICE_ACCOUNT", secrets: typing.Optional[typing.List[str]] = None, namespace: str = "METAFLOW_KUBERNETES_NAMESPACE", gpu: typing.Optional[int] = None, gpu_vendor: str = "KUBERNETES_GPU_VENDOR", tolerations: typing.List[str] = [], use_tmpfs: bool = False, tmpfs_tempdir: bool = True, tmpfs_size: typing.Optional[int] = None, tmpfs_path: typing.Optional[str] = "/metaflow_temp", persistent_volume_claims: typing.Optional[typing.Dict[str, str]] = None, port: typing.Optional[int] = None, shared_memory: typing.Optional[int] = None) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies that this step should execute on Kubernetes.
+    
+    Parameters
+    ----------
+    cpu : int, default 1
+        Number of CPUs required for this step. If `@resources` is
+        also present, the maximum value from all decorators is used.
+    memory : int, default 4096
+        Memory size (in MB) required for this step. If
+        `@resources` is also present, the maximum value from all decorators is
+        used.
+    disk : int, default 10240
+        Disk size (in MB) required for this step. If
+        `@resources` is also present, the maximum value from all decorators is
+        used.
+    image : str, optional, default None
+        Docker image to use when launching on Kubernetes. If not specified, and
+        METAFLOW_KUBERNETES_CONTAINER_IMAGE is specified, that image is used. If
+        not, a default Docker image mapping to the current version of Python is used.
+    image_pull_policy: str, default KUBERNETES_IMAGE_PULL_POLICY
+        If given, the imagePullPolicy to be applied to the Docker image of the step.
+    service_account : str, default METAFLOW_KUBERNETES_SERVICE_ACCOUNT
+        Kubernetes service account to use when launching pod in Kubernetes.
+    secrets : List[str], optional, default None
+        Kubernetes secrets to use when launching pod in Kubernetes. These
+        secrets are in addition to the ones defined in `METAFLOW_KUBERNETES_SECRETS`
+        in Metaflow configuration.
+    namespace : str, default METAFLOW_KUBERNETES_NAMESPACE
+        Kubernetes namespace to use when launching pod in Kubernetes.
+    gpu : int, optional, default None
+        Number of GPUs required for this step. A value of zero implies that
+        the scheduled node should not have GPUs.
+    gpu_vendor : str, default KUBERNETES_GPU_VENDOR
+        The vendor of the GPUs to be used for this step.
+    tolerations : List[str], default []
+        The default is extracted from METAFLOW_KUBERNETES_TOLERATIONS.
+        Kubernetes tolerations to use when launching pod in Kubernetes.
+    use_tmpfs : bool, default False
+        This enables an explicit tmpfs mount for this step.
+    tmpfs_tempdir : bool, default True
+        sets METAFLOW_TEMPDIR to tmpfs_path if set for this step.
+    tmpfs_size : int, optional, default: None
+        The value for the size (in MiB) of the tmpfs mount for this step.
+        This parameter maps to the `--tmpfs` option in Docker. Defaults to 50% of the
+        memory allocated for this step.
+    tmpfs_path : str, optional, default /metaflow_temp
+        Path to tmpfs mount for this step.
+    persistent_volume_claims : Dict[str, str], optional, default None
+        A map (dictionary) of persistent volumes to be mounted to the pod for this step. The map is from persistent
+        volumes to the path to which the volume is to be mounted, e.g., `{'pvc-name': '/path/to/mount/on'}`.
+    port: int, optional
+        Number of the port to specify in the Kubernetes job object
+    shared_memory: int, optional
+        Shared memory size (in MiB) required for this steps
+    """
+    ...
+
+@typing.overload
+def retry(*, times: int = 3, minutes_between_retries: int = 2) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies the number of times the task corresponding
+    to a step needs to be retried.
+    
+    This decorator is useful for handling transient errors, such as networking issues.
+    If your task contains operations that can't be retried safely, e.g. database updates,
+    it is advisable to annotate it with `@retry(times=0)`.
+    
+    This can be used in conjunction with the `@catch` decorator. The `@catch`
+    decorator will execute a no-op task after all retries have been exhausted,
+    ensuring that the flow execution can continue.
+    
+    Parameters
+    ----------
+    times : int, default 3
+        Number of times to retry this task.
+    minutes_between_retries : int, default 2
+        Number of minutes between retries.
+    """
+    ...
+
+@typing.overload
+def retry(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def retry(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def retry(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, times: int = 3, minutes_between_retries: int = 2):
+    """
+    Specifies the number of times the task corresponding
+    to a step needs to be retried.
+    
+    This decorator is useful for handling transient errors, such as networking issues.
+    If your task contains operations that can't be retried safely, e.g. database updates,
+    it is advisable to annotate it with `@retry(times=0)`.
+    
+    This can be used in conjunction with the `@catch` decorator. The `@catch`
+    decorator will execute a no-op task after all retries have been exhausted,
+    ensuring that the flow execution can continue.
+    
+    Parameters
+    ----------
+    times : int, default 3
+        Number of times to retry this task.
+    minutes_between_retries : int, default 2
+        Number of minutes between retries.
+    """
+    ...
+
+@typing.overload
+def pypi(*, packages: typing.Dict[str, str] = {}, python: typing.Optional[str] = None) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies the PyPI packages for the step.
+    
+    Information in this decorator will augment any
+    attributes set in the `@pyi_base` flow-level decorator. Hence,
+    you can use `@pypi_base` to set packages required by all
+    steps and use `@pypi` to specify step-specific overrides.
+    
+    Parameters
+    ----------
+    packages : Dict[str, str], default: {}
+        Packages to use for this step. The key is the name of the package
+        and the value is the version to use.
+    python : str, optional, default: None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    """
+    ...
+
+@typing.overload
+def pypi(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def pypi(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def pypi(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, packages: typing.Dict[str, str] = {}, python: typing.Optional[str] = None):
+    """
+    Specifies the PyPI packages for the step.
+    
+    Information in this decorator will augment any
+    attributes set in the `@pyi_base` flow-level decorator. Hence,
+    you can use `@pypi_base` to set packages required by all
+    steps and use `@pypi` to specify step-specific overrides.
+    
+    Parameters
+    ----------
+    packages : Dict[str, str], default: {}
+        Packages to use for this step. The key is the name of the package
+        and the value is the version to use.
+    python : str, optional, default: None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    """
+    ...
+
+@typing.overload
+def card(*, type: str = "default", id: typing.Optional[str] = None, options: typing.Dict[str, typing.Any] = {}, timeout: int = 45) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Creates a human-readable report, a Metaflow Card, after this step completes.
+    
+    Note that you may add multiple `@card` decorators in a step with different parameters.
+    
+    Parameters
+    ----------
+    type : str, default 'default'
+        Card type.
+    id : str, optional, default None
+        If multiple cards are present, use this id to identify this card.
+    options : Dict[str, Any], default {}
+        Options passed to the card. The contents depend on the card type.
+    timeout : int, default 45
+        Interrupt reporting if it takes more than this many seconds.
+    
+    
+    """
+    ...
+
+@typing.overload
+def card(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def card(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def card(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, type: str = "default", id: typing.Optional[str] = None, options: typing.Dict[str, typing.Any] = {}, timeout: int = 45):
+    """
+    Creates a human-readable report, a Metaflow Card, after this step completes.
+    
+    Note that you may add multiple `@card` decorators in a step with different parameters.
+    
+    Parameters
+    ----------
+    type : str, default 'default'
+        Card type.
+    id : str, optional, default None
+        If multiple cards are present, use this id to identify this card.
+    options : Dict[str, Any], default {}
+        Options passed to the card. The contents depend on the card type.
+    timeout : int, default 45
+        Interrupt reporting if it takes more than this many seconds.
+    
+    
+    """
+    ...
+
+@typing.overload
+def catch(*, var: typing.Optional[str] = None, print_exception: bool = True) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies that the step will success under all circumstances.
+    
+    The decorator will create an optional artifact, specified by `var`, which
+    contains the exception raised. You can use it to detect the presence
+    of errors, indicating that all happy-path artifacts produced by the step
+    are missing.
+    
+    Parameters
+    ----------
+    var : str, optional, default None
+        Name of the artifact in which to store the caught exception.
+        If not specified, the exception is not stored.
+    print_exception : bool, default True
+        Determines whether or not the exception is printed to
+        stdout when caught.
+    """
+    ...
+
+@typing.overload
+def catch(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def catch(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def catch(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, var: typing.Optional[str] = None, print_exception: bool = True):
+    """
+    Specifies that the step will success under all circumstances.
+    
+    The decorator will create an optional artifact, specified by `var`, which
+    contains the exception raised. You can use it to detect the presence
+    of errors, indicating that all happy-path artifacts produced by the step
+    are missing.
+    
+    Parameters
+    ----------
+    var : str, optional, default None
+        Name of the artifact in which to store the caught exception.
+        If not specified, the exception is not stored.
+    print_exception : bool, default True
+        Determines whether or not the exception is printed to
+        stdout when caught.
+    """
+    ...
+
+@typing.overload
+def resources(*, cpu: int = 1, gpu: int = 0, disk: typing.Optional[int] = None, memory: int = 4096, shared_memory: typing.Optional[int] = None) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies the resources needed when executing this step.
+    
+    Use `@resources` to specify the resource requirements
+    independently of the specific compute layer (`@batch`, `@kubernetes`).
+    
+    You can choose the compute layer on the command line by executing e.g.
+    ```
+    python myflow.py run --with batch
+    ```
+    or
+    ```
+    python myflow.py run --with kubernetes
+    ```
+    which executes the flow on the desired system using the
+    requirements specified in `@resources`.
+    
+    Parameters
+    ----------
+    cpu : int, default 1
+        Number of CPUs required for this step.
+    gpu : int, default 0
+        Number of GPUs required for this step.
+    disk : int, optional, default None
+        Disk size (in MB) required for this step. Only applies on Kubernetes.
+    memory : int, default 4096
+        Memory size (in MB) required for this step.
+    shared_memory : int, optional, default None
+        The value for the size (in MiB) of the /dev/shm volume for this step.
+        This parameter maps to the `--shm-size` option in Docker.
+    """
+    ...
+
+@typing.overload
+def resources(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def resources(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def resources(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, cpu: int = 1, gpu: int = 0, disk: typing.Optional[int] = None, memory: int = 4096, shared_memory: typing.Optional[int] = None):
+    """
+    Specifies the resources needed when executing this step.
+    
+    Use `@resources` to specify the resource requirements
+    independently of the specific compute layer (`@batch`, `@kubernetes`).
+    
+    You can choose the compute layer on the command line by executing e.g.
+    ```
+    python myflow.py run --with batch
+    ```
+    or
+    ```
+    python myflow.py run --with kubernetes
+    ```
+    which executes the flow on the desired system using the
+    requirements specified in `@resources`.
+    
+    Parameters
+    ----------
+    cpu : int, default 1
+        Number of CPUs required for this step.
+    gpu : int, default 0
+        Number of GPUs required for this step.
+    disk : int, optional, default None
+        Disk size (in MB) required for this step. Only applies on Kubernetes.
+    memory : int, default 4096
+        Memory size (in MB) required for this step.
+    shared_memory : int, optional, default None
+        The value for the size (in MiB) of the /dev/shm volume for this step.
+        This parameter maps to the `--shm-size` option in Docker.
+    """
+    ...
+
+@typing.overload
+def timeout(*, seconds: int = 0, minutes: int = 0, hours: int = 0) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies a timeout for your step.
+    
+    This decorator is useful if this step may hang indefinitely.
+    
+    This can be used in conjunction with the `@retry` decorator as well as the `@catch` decorator.
+    A timeout is considered to be an exception thrown by the step. It will cause the step to be
+    retried if needed and the exception will be caught by the `@catch` decorator, if present.
+    
+    Note that all the values specified in parameters are added together so if you specify
+    60 seconds and 1 hour, the decorator will have an effective timeout of 1 hour and 1 minute.
+    
+    Parameters
+    ----------
+    seconds : int, default 0
+        Number of seconds to wait prior to timing out.
+    minutes : int, default 0
+        Number of minutes to wait prior to timing out.
+    hours : int, default 0
+        Number of hours to wait prior to timing out.
+    """
+    ...
+
+@typing.overload
+def timeout(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def timeout(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def timeout(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, seconds: int = 0, minutes: int = 0, hours: int = 0):
+    """
+    Specifies a timeout for your step.
+    
+    This decorator is useful if this step may hang indefinitely.
+    
+    This can be used in conjunction with the `@retry` decorator as well as the `@catch` decorator.
+    A timeout is considered to be an exception thrown by the step. It will cause the step to be
+    retried if needed and the exception will be caught by the `@catch` decorator, if present.
+    
+    Note that all the values specified in parameters are added together so if you specify
+    60 seconds and 1 hour, the decorator will have an effective timeout of 1 hour and 1 minute.
+    
+    Parameters
+    ----------
+    seconds : int, default 0
+        Number of seconds to wait prior to timing out.
+    minutes : int, default 0
+        Number of minutes to wait prior to timing out.
+    hours : int, default 0
+        Number of hours to wait prior to timing out.
+    """
+    ...
+
+@typing.overload
+def conda(*, packages: typing.Dict[str, str] = {}, libraries: typing.Dict[str, str] = {}, python: typing.Optional[str] = None, disabled: bool = False) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies the Conda environment for the step.
+    
+    Information in this decorator will augment any
+    attributes set in the `@conda_base` flow-level decorator. Hence,
+    you can use `@conda_base` to set packages required by all
+    steps and use `@conda` to specify step-specific overrides.
+    
+    Parameters
+    ----------
+    packages : Dict[str, str], default {}
+        Packages to use for this step. The key is the name of the package
+        and the value is the version to use.
+    libraries : Dict[str, str], default {}
+        Supported for backward compatibility. When used with packages, packages will take precedence.
+    python : str, optional, default None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    disabled : bool, default False
+        If set to True, disables @conda.
+    """
+    ...
+
+@typing.overload
+def conda(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def conda(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def conda(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, packages: typing.Dict[str, str] = {}, libraries: typing.Dict[str, str] = {}, python: typing.Optional[str] = None, disabled: bool = False):
+    """
+    Specifies the Conda environment for the step.
+    
+    Information in this decorator will augment any
+    attributes set in the `@conda_base` flow-level decorator. Hence,
+    you can use `@conda_base` to set packages required by all
+    steps and use `@conda` to specify step-specific overrides.
+    
+    Parameters
+    ----------
+    packages : Dict[str, str], default {}
+        Packages to use for this step. The key is the name of the package
+        and the value is the version to use.
+    libraries : Dict[str, str], default {}
+        Supported for backward compatibility. When used with packages, packages will take precedence.
+    python : str, optional, default None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    disabled : bool, default False
+        If set to True, disables @conda.
+    """
+    ...
+
+@typing.overload
+def batch(*, cpu: int = 1, gpu: int = 0, memory: int = 4096, image: typing.Optional[str] = None, queue: str = "METAFLOW_BATCH_JOB_QUEUE", iam_role: str = "METAFLOW_ECS_S3_ACCESS_IAM_ROLE", execution_role: str = "METAFLOW_ECS_FARGATE_EXECUTION_ROLE", shared_memory: typing.Optional[int] = None, max_swap: typing.Optional[int] = None, swappiness: typing.Optional[int] = None, use_tmpfs: bool = False, tmpfs_tempdir: bool = True, tmpfs_size: typing.Optional[int] = None, tmpfs_path: typing.Optional[str] = None, inferentia: int = 0, efa: int = 0) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies that this step should execute on [AWS Batch](https://aws.amazon.com/batch/).
+    
+    Parameters
+    ----------
+    cpu : int, default 1
+        Number of CPUs required for this step. If `@resources` is
+        also present, the maximum value from all decorators is used.
+    gpu : int, default 0
+        Number of GPUs required for this step. If `@resources` is
+        also present, the maximum value from all decorators is used.
+    memory : int, default 4096
+        Memory size (in MB) required for this step. If
+        `@resources` is also present, the maximum value from all decorators is
+        used.
+    image : str, optional, default None
+        Docker image to use when launching on AWS Batch. If not specified, and
+        METAFLOW_BATCH_CONTAINER_IMAGE is specified, that image is used. If
+        not, a default Docker image mapping to the current version of Python is used.
+    queue : str, default METAFLOW_BATCH_JOB_QUEUE
+        AWS Batch Job Queue to submit the job to.
+    iam_role : str, default METAFLOW_ECS_S3_ACCESS_IAM_ROLE
+        AWS IAM role that AWS Batch container uses to access AWS cloud resources.
+    execution_role : str, default METAFLOW_ECS_FARGATE_EXECUTION_ROLE
+        AWS IAM role that AWS Batch can use [to trigger AWS Fargate tasks]
+        (https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html).
+    shared_memory : int, optional, default None
+        The value for the size (in MiB) of the /dev/shm volume for this step.
+        This parameter maps to the `--shm-size` option in Docker.
+    max_swap : int, optional, default None
+        The total amount of swap memory (in MiB) a container can use for this
+        step. This parameter is translated to the `--memory-swap` option in
+        Docker where the value is the sum of the container memory plus the
+        `max_swap` value.
+    swappiness : int, optional, default None
+        This allows you to tune memory swappiness behavior for this step.
+        A swappiness value of 0 causes swapping not to happen unless absolutely
+        necessary. A swappiness value of 100 causes pages to be swapped very
+        aggressively. Accepted values are whole numbers between 0 and 100.
+    use_tmpfs : bool, default False
+        This enables an explicit tmpfs mount for this step.
+    tmpfs_tempdir : bool, default True
+        sets METAFLOW_TEMPDIR to tmpfs_path if set for this step.
+    tmpfs_size : int, optional, default None
+        The value for the size (in MiB) of the tmpfs mount for this step.
+        This parameter maps to the `--tmpfs` option in Docker. Defaults to 50% of the
+        memory allocated for this step.
+    tmpfs_path : str, optional, default None
+        Path to tmpfs mount for this step. Defaults to /metaflow_temp.
+    inferentia : int, default 0
+        Number of Inferentia chips required for this step.
+    efa : int, default 0
+        Number of elastic fabric adapter network devices to attach to container
+    """
+    ...
+
+@typing.overload
+def batch(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def batch(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def batch(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, cpu: int = 1, gpu: int = 0, memory: int = 4096, image: typing.Optional[str] = None, queue: str = "METAFLOW_BATCH_JOB_QUEUE", iam_role: str = "METAFLOW_ECS_S3_ACCESS_IAM_ROLE", execution_role: str = "METAFLOW_ECS_FARGATE_EXECUTION_ROLE", shared_memory: typing.Optional[int] = None, max_swap: typing.Optional[int] = None, swappiness: typing.Optional[int] = None, use_tmpfs: bool = False, tmpfs_tempdir: bool = True, tmpfs_size: typing.Optional[int] = None, tmpfs_path: typing.Optional[str] = None, inferentia: int = 0, efa: int = 0):
+    """
+    Specifies that this step should execute on [AWS Batch](https://aws.amazon.com/batch/).
+    
+    Parameters
+    ----------
+    cpu : int, default 1
+        Number of CPUs required for this step. If `@resources` is
+        also present, the maximum value from all decorators is used.
+    gpu : int, default 0
+        Number of GPUs required for this step. If `@resources` is
+        also present, the maximum value from all decorators is used.
+    memory : int, default 4096
+        Memory size (in MB) required for this step. If
+        `@resources` is also present, the maximum value from all decorators is
+        used.
+    image : str, optional, default None
+        Docker image to use when launching on AWS Batch. If not specified, and
+        METAFLOW_BATCH_CONTAINER_IMAGE is specified, that image is used. If
+        not, a default Docker image mapping to the current version of Python is used.
+    queue : str, default METAFLOW_BATCH_JOB_QUEUE
+        AWS Batch Job Queue to submit the job to.
+    iam_role : str, default METAFLOW_ECS_S3_ACCESS_IAM_ROLE
+        AWS IAM role that AWS Batch container uses to access AWS cloud resources.
+    execution_role : str, default METAFLOW_ECS_FARGATE_EXECUTION_ROLE
+        AWS IAM role that AWS Batch can use [to trigger AWS Fargate tasks]
+        (https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html).
+    shared_memory : int, optional, default None
+        The value for the size (in MiB) of the /dev/shm volume for this step.
+        This parameter maps to the `--shm-size` option in Docker.
+    max_swap : int, optional, default None
+        The total amount of swap memory (in MiB) a container can use for this
+        step. This parameter is translated to the `--memory-swap` option in
+        Docker where the value is the sum of the container memory plus the
+        `max_swap` value.
+    swappiness : int, optional, default None
+        This allows you to tune memory swappiness behavior for this step.
+        A swappiness value of 0 causes swapping not to happen unless absolutely
+        necessary. A swappiness value of 100 causes pages to be swapped very
+        aggressively. Accepted values are whole numbers between 0 and 100.
+    use_tmpfs : bool, default False
+        This enables an explicit tmpfs mount for this step.
+    tmpfs_tempdir : bool, default True
+        sets METAFLOW_TEMPDIR to tmpfs_path if set for this step.
+    tmpfs_size : int, optional, default None
+        The value for the size (in MiB) of the tmpfs mount for this step.
+        This parameter maps to the `--tmpfs` option in Docker. Defaults to 50% of the
+        memory allocated for this step.
+    tmpfs_path : str, optional, default None
+        Path to tmpfs mount for this step. Defaults to /metaflow_temp.
+    inferentia : int, default 0
+        Number of Inferentia chips required for this step.
+    efa : int, default 0
+        Number of elastic fabric adapter network devices to attach to container
+    """
+    ...
+
+@typing.overload
+def secrets(*, sources: typing.List[typing.Union[str, typing.Dict[str, typing.Any]]] = []) -> typing.Callable[[typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]], typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]]]:
+    """
+    Specifies secrets to be retrieved and injected as environment variables prior to
+    the execution of a step.
+    
+    Parameters
+    ----------
+    sources : List[Union[str, Dict[str, Any]]], default: []
+        List of secret specs, defining how the secrets are to be retrieved
+    """
+    ...
+
+@typing.overload
+def secrets(f: typing.Callable[[FlowSpecDerived, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, StepFlag], None]:
+    ...
+
+@typing.overload
+def secrets(f: typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]) -> typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None]:
+    ...
+
+def secrets(f: typing.Union[typing.Callable[[FlowSpecDerived, StepFlag], None], typing.Callable[[FlowSpecDerived, typing.Any, StepFlag], None], None] = None, *, sources: typing.List[typing.Union[str, typing.Dict[str, typing.Any]]] = []):
+    """
+    Specifies secrets to be retrieved and injected as environment variables prior to
+    the execution of a step.
+    
+    Parameters
+    ----------
+    sources : List[Union[str, Dict[str, Any]]], default: []
+        List of secret specs, defining how the secrets are to be retrieved
+    """
+    ...
+
+@typing.overload
+def trigger(*, event: typing.Union[str, typing.Dict[str, typing.Any], None] = None, events: typing.List[typing.Union[str, typing.Dict[str, typing.Any]]] = [], options: typing.Dict[str, typing.Any] = {}) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    Specifies the event(s) that this flow depends on.
+    
+    ```
+    @trigger(event='foo')
+    ```
+    or
+    ```
+    @trigger(events=['foo', 'bar'])
+    ```
+    
+    Additionally, you can specify the parameter mappings
+    to map event payload to Metaflow parameters for the flow.
+    ```
+    @trigger(event={'name':'foo', 'parameters':{'flow_param': 'event_field'}})
+    ```
+    or
+    ```
+    @trigger(events=[{'name':'foo', 'parameters':{'flow_param_1': 'event_field_1'},
+                     {'name':'bar', 'parameters':{'flow_param_2': 'event_field_2'}])
+    ```
+    
+    'parameters' can also be a list of strings and tuples like so:
+    ```
+    @trigger(event={'name':'foo', 'parameters':['common_name', ('flow_param', 'event_field')]})
+    ```
+    This is equivalent to:
+    ```
+    @trigger(event={'name':'foo', 'parameters':{'common_name': 'common_name', 'flow_param': 'event_field'}})
+    ```
+    
+    Parameters
+    ----------
+    event : Union[str, Dict[str, Any]], optional, default None
+        Event dependency for this flow.
+    events : List[Union[str, Dict[str, Any]]], default []
+        Events dependency for this flow.
+    options : Dict[str, Any], default {}
+        Backend-specific configuration for tuning eventing behavior.
+    
+    
+    """
+    ...
+
+@typing.overload
+def trigger(f: typing.Type[FlowSpecDerived]) -> typing.Type[FlowSpecDerived]:
+    ...
+
+def trigger(f: typing.Optional[typing.Type[FlowSpecDerived]] = None, *, event: typing.Union[str, typing.Dict[str, typing.Any], None] = None, events: typing.List[typing.Union[str, typing.Dict[str, typing.Any]]] = [], options: typing.Dict[str, typing.Any] = {}):
+    """
+    Specifies the event(s) that this flow depends on.
+    
+    ```
+    @trigger(event='foo')
+    ```
+    or
+    ```
+    @trigger(events=['foo', 'bar'])
+    ```
+    
+    Additionally, you can specify the parameter mappings
+    to map event payload to Metaflow parameters for the flow.
+    ```
+    @trigger(event={'name':'foo', 'parameters':{'flow_param': 'event_field'}})
+    ```
+    or
+    ```
+    @trigger(events=[{'name':'foo', 'parameters':{'flow_param_1': 'event_field_1'},
+                     {'name':'bar', 'parameters':{'flow_param_2': 'event_field_2'}])
+    ```
+    
+    'parameters' can also be a list of strings and tuples like so:
+    ```
+    @trigger(event={'name':'foo', 'parameters':['common_name', ('flow_param', 'event_field')]})
+    ```
+    This is equivalent to:
+    ```
+    @trigger(event={'name':'foo', 'parameters':{'common_name': 'common_name', 'flow_param': 'event_field'}})
+    ```
+    
+    Parameters
+    ----------
+    event : Union[str, Dict[str, Any]], optional, default None
+        Event dependency for this flow.
+    events : List[Union[str, Dict[str, Any]]], default []
+        Events dependency for this flow.
+    options : Dict[str, Any], default {}
+        Backend-specific configuration for tuning eventing behavior.
+    
+    
+    """
+    ...
+
+def airflow_external_task_sensor(*, timeout: int, poke_interval: int, mode: str, exponential_backoff: bool, pool: str, soft_fail: bool, name: str, description: str, external_dag_id: str, external_task_ids: typing.List[str], allowed_states: typing.List[str], failed_states: typing.List[str], execution_delta: "datetime.timedelta", check_existence: bool) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    The `@airflow_external_task_sensor` decorator attaches a Airflow [ExternalTaskSensor](https://airflow.apache.org/docs/apache-airflow/stable/_api/airflow/sensors/external_task/index.html#airflow.sensors.external_task.ExternalTaskSensor) before the start step of the flow.
+    This decorator only works when a flow is scheduled on Airflow and is compiled using `airflow create`. More than one `@airflow_external_task_sensor` can be added as a flow decorators. Adding more than one decorator will ensure that `start` step starts only after all sensors finish.
+    
+    Parameters
+    ----------
+    timeout : int
+        Time, in seconds before the task times out and fails. (Default: 3600)
+    poke_interval : int
+        Time in seconds that the job should wait in between each try. (Default: 60)
+    mode : str
+        How the sensor operates. Options are: { poke | reschedule }. (Default: "poke")
+    exponential_backoff : bool
+        allow progressive longer waits between pokes by using exponential backoff algorithm. (Default: True)
+    pool : str
+        the slot pool this task should run in,
+        slot pools are a way to limit concurrency for certain tasks. (Default:None)
+    soft_fail : bool
+        Set to true to mark the task as SKIPPED on failure. (Default: False)
+    name : str
+        Name of the sensor on Airflow
+    description : str
+        Description of sensor in the Airflow UI
+    external_dag_id : str
+        The dag_id that contains the task you want to wait for.
+    external_task_ids : List[str]
+        The list of task_ids that you want to wait for.
+        If None (default value) the sensor waits for the DAG. (Default: None)
+    allowed_states : List[str]
+        Iterable of allowed states, (Default: ['success'])
+    failed_states : List[str]
+        Iterable of failed or dis-allowed states. (Default: None)
+    execution_delta : datetime.timedelta
+        time difference with the previous execution to look at,
+        the default is the same logical date as the current task or DAG. (Default: None)
+    check_existence: bool
+        Set to True to check if the external task exists or check if
+        the DAG to wait for exists. (Default: True)
+    """
+    ...
+
+@typing.overload
+def trigger_on_finish(*, flow: typing.Union[str, typing.Dict[str, str], None] = None, flows: typing.List[typing.Union[str, typing.Dict[str, str]]] = [], options: typing.Dict[str, typing.Any] = {}) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    Specifies the flow(s) that this flow depends on.
+    
+    ```
+    @trigger_on_finish(flow='FooFlow')
+    ```
+    or
+    ```
+    @trigger_on_finish(flows=['FooFlow', 'BarFlow'])
+    ```
+    This decorator respects the @project decorator and triggers the flow
+    when upstream runs within the same namespace complete successfully
+    
+    Additionally, you can specify project aware upstream flow dependencies
+    by specifying the fully qualified project_flow_name.
+    ```
+    @trigger_on_finish(flow='my_project.branch.my_branch.FooFlow')
+    ```
+    or
+    ```
+    @trigger_on_finish(flows=['my_project.branch.my_branch.FooFlow', 'BarFlow'])
+    ```
+    
+    You can also specify just the project or project branch (other values will be
+    inferred from the current project or project branch):
+    ```
+    @trigger_on_finish(flow={"name": "FooFlow", "project": "my_project", "project_branch": "branch"})
+    ```
+    
+    Note that `branch` is typically one of:
+      - `prod`
+      - `user.bob`
+      - `test.my_experiment`
+      - `prod.staging`
+    
+    Parameters
+    ----------
+    flow : Union[str, Dict[str, str]], optional, default None
+        Upstream flow dependency for this flow.
+    flows : List[Union[str, Dict[str, str]]], default []
+        Upstream flow dependencies for this flow.
+    options : Dict[str, Any], default {}
+        Backend-specific configuration for tuning eventing behavior.
+    
+    
+    """
+    ...
+
+@typing.overload
+def trigger_on_finish(f: typing.Type[FlowSpecDerived]) -> typing.Type[FlowSpecDerived]:
+    ...
+
+def trigger_on_finish(f: typing.Optional[typing.Type[FlowSpecDerived]] = None, *, flow: typing.Union[str, typing.Dict[str, str], None] = None, flows: typing.List[typing.Union[str, typing.Dict[str, str]]] = [], options: typing.Dict[str, typing.Any] = {}):
+    """
+    Specifies the flow(s) that this flow depends on.
+    
+    ```
+    @trigger_on_finish(flow='FooFlow')
+    ```
+    or
+    ```
+    @trigger_on_finish(flows=['FooFlow', 'BarFlow'])
+    ```
+    This decorator respects the @project decorator and triggers the flow
+    when upstream runs within the same namespace complete successfully
+    
+    Additionally, you can specify project aware upstream flow dependencies
+    by specifying the fully qualified project_flow_name.
+    ```
+    @trigger_on_finish(flow='my_project.branch.my_branch.FooFlow')
+    ```
+    or
+    ```
+    @trigger_on_finish(flows=['my_project.branch.my_branch.FooFlow', 'BarFlow'])
+    ```
+    
+    You can also specify just the project or project branch (other values will be
+    inferred from the current project or project branch):
+    ```
+    @trigger_on_finish(flow={"name": "FooFlow", "project": "my_project", "project_branch": "branch"})
+    ```
+    
+    Note that `branch` is typically one of:
+      - `prod`
+      - `user.bob`
+      - `test.my_experiment`
+      - `prod.staging`
+    
+    Parameters
+    ----------
+    flow : Union[str, Dict[str, str]], optional, default None
+        Upstream flow dependency for this flow.
+    flows : List[Union[str, Dict[str, str]]], default []
+        Upstream flow dependencies for this flow.
+    options : Dict[str, Any], default {}
+        Backend-specific configuration for tuning eventing behavior.
+    
+    
+    """
+    ...
+
+def project(*, name: str) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    Specifies what flows belong to the same project.
+    
+    A project-specific namespace is created for all flows that
+    use the same `@project(name)`.
+    
+    Parameters
+    ----------
+    name : str
+        Project name. Make sure that the name is unique amongst all
+        projects that use the same production scheduler. The name may
+        contain only lowercase alphanumeric characters and underscores.
+    
+    
+    """
+    ...
+
+def airflow_s3_key_sensor(*, timeout: int, poke_interval: int, mode: str, exponential_backoff: bool, pool: str, soft_fail: bool, name: str, description: str, bucket_key: typing.Union[str, typing.List[str]], bucket_name: str, wildcard_match: bool, aws_conn_id: str, verify: bool) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    The `@airflow_s3_key_sensor` decorator attaches a Airflow [S3KeySensor](https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/_api/airflow/providers/amazon/aws/sensors/s3/index.html#airflow.providers.amazon.aws.sensors.s3.S3KeySensor)
+    before the start step of the flow. This decorator only works when a flow is scheduled on Airflow
+    and is compiled using `airflow create`. More than one `@airflow_s3_key_sensor` can be
+    added as a flow decorators. Adding more than one decorator will ensure that `start` step
+    starts only after all sensors finish.
+    
+    Parameters
+    ----------
+    timeout : int
+        Time, in seconds before the task times out and fails. (Default: 3600)
+    poke_interval : int
+        Time in seconds that the job should wait in between each try. (Default: 60)
+    mode : str
+        How the sensor operates. Options are: { poke | reschedule }. (Default: "poke")
+    exponential_backoff : bool
+        allow progressive longer waits between pokes by using exponential backoff algorithm. (Default: True)
+    pool : str
+        the slot pool this task should run in,
+        slot pools are a way to limit concurrency for certain tasks. (Default:None)
+    soft_fail : bool
+        Set to true to mark the task as SKIPPED on failure. (Default: False)
+    name : str
+        Name of the sensor on Airflow
+    description : str
+        Description of sensor in the Airflow UI
+    bucket_key : Union[str, List[str]]
+        The key(s) being waited on. Supports full s3:// style url or relative path from root level.
+        When it's specified as a full s3:// url, please leave `bucket_name` as None
+    bucket_name : str
+        Name of the S3 bucket. Only needed when bucket_key is not provided as a full s3:// url.
+        When specified, all the keys passed to bucket_key refers to this bucket. (Default:None)
+    wildcard_match : bool
+        whether the bucket_key should be interpreted as a Unix wildcard pattern. (Default: False)
+    aws_conn_id : str
+        a reference to the s3 connection on Airflow. (Default: None)
+    verify : bool
+        Whether or not to verify SSL certificates for S3 connection. (Default: None)
+    """
+    ...
+
+@typing.overload
+def conda_base(*, packages: typing.Dict[str, str] = {}, libraries: typing.Dict[str, str] = {}, python: typing.Optional[str] = None, disabled: bool = False) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    Specifies the Conda environment for all steps of the flow.
+    
+    Use `@conda_base` to set common libraries required by all
+    steps and use `@conda` to specify step-specific additions.
+    
+    Parameters
+    ----------
+    packages : Dict[str, str], default {}
+        Packages to use for this flow. The key is the name of the package
+        and the value is the version to use.
+    libraries : Dict[str, str], default {}
+        Supported for backward compatibility. When used with packages, packages will take precedence.
+    python : str, optional, default None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    disabled : bool, default False
+        If set to True, disables Conda.
+    """
+    ...
+
+@typing.overload
+def conda_base(f: typing.Type[FlowSpecDerived]) -> typing.Type[FlowSpecDerived]:
+    ...
+
+def conda_base(f: typing.Optional[typing.Type[FlowSpecDerived]] = None, *, packages: typing.Dict[str, str] = {}, libraries: typing.Dict[str, str] = {}, python: typing.Optional[str] = None, disabled: bool = False):
+    """
+    Specifies the Conda environment for all steps of the flow.
+    
+    Use `@conda_base` to set common libraries required by all
+    steps and use `@conda` to specify step-specific additions.
+    
+    Parameters
+    ----------
+    packages : Dict[str, str], default {}
+        Packages to use for this flow. The key is the name of the package
+        and the value is the version to use.
+    libraries : Dict[str, str], default {}
+        Supported for backward compatibility. When used with packages, packages will take precedence.
+    python : str, optional, default None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    disabled : bool, default False
+        If set to True, disables Conda.
+    """
+    ...
+
+@typing.overload
+def schedule(*, hourly: bool = False, daily: bool = True, weekly: bool = False, cron: typing.Optional[str] = None, timezone: typing.Optional[str] = None) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    Specifies the times when the flow should be run when running on a
+    production scheduler.
+    
+    Parameters
+    ----------
+    hourly : bool, default False
+        Run the workflow hourly.
+    daily : bool, default True
+        Run the workflow daily.
+    weekly : bool, default False
+        Run the workflow weekly.
+    cron : str, optional, default None
+        Run the workflow at [a custom Cron schedule](https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html#cron-expressions)
+        specified by this expression.
+    timezone : str, optional, default None
+        Timezone on which the schedule runs (default: None). Currently supported only for Argo workflows,
+        which accepts timezones in [IANA format](https://nodatime.org/TimeZones).
+    """
+    ...
+
+@typing.overload
+def schedule(f: typing.Type[FlowSpecDerived]) -> typing.Type[FlowSpecDerived]:
+    ...
+
+def schedule(f: typing.Optional[typing.Type[FlowSpecDerived]] = None, *, hourly: bool = False, daily: bool = True, weekly: bool = False, cron: typing.Optional[str] = None, timezone: typing.Optional[str] = None):
+    """
+    Specifies the times when the flow should be run when running on a
+    production scheduler.
+    
+    Parameters
+    ----------
+    hourly : bool, default False
+        Run the workflow hourly.
+    daily : bool, default True
+        Run the workflow daily.
+    weekly : bool, default False
+        Run the workflow weekly.
+    cron : str, optional, default None
+        Run the workflow at [a custom Cron schedule](https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html#cron-expressions)
+        specified by this expression.
+    timezone : str, optional, default None
+        Timezone on which the schedule runs (default: None). Currently supported only for Argo workflows,
+        which accepts timezones in [IANA format](https://nodatime.org/TimeZones).
+    """
+    ...
+
+@typing.overload
+def pypi_base(*, packages: typing.Dict[str, str] = {}, python: typing.Optional[str] = None) -> typing.Callable[[typing.Type[FlowSpecDerived]], typing.Type[FlowSpecDerived]]:
+    """
+    Specifies the PyPI packages for all steps of the flow.
+    
+    Use `@pypi_base` to set common packages required by all
+    steps and use `@pypi` to specify step-specific overrides.
+    Parameters
+    ----------
+    packages : Dict[str, str], default: {}
+        Packages to use for this flow. The key is the name of the package
+        and the value is the version to use.
+    python : str, optional, default: None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    """
+    ...
+
+@typing.overload
+def pypi_base(f: typing.Type[FlowSpecDerived]) -> typing.Type[FlowSpecDerived]:
+    ...
+
+def pypi_base(f: typing.Optional[typing.Type[FlowSpecDerived]] = None, *, packages: typing.Dict[str, str] = {}, python: typing.Optional[str] = None):
+    """
+    Specifies the PyPI packages for all steps of the flow.
+    
+    Use `@pypi_base` to set common packages required by all
+    steps and use `@pypi` to specify step-specific overrides.
+    Parameters
+    ----------
+    packages : Dict[str, str], default: {}
+        Packages to use for this flow. The key is the name of the package
+        and the value is the version to use.
+    python : str, optional, default: None
+        Version of Python to use, e.g. '3.7.4'. A default value of None implies
+        that the version used will correspond to the version of the Python interpreter used to start the run.
+    """
+    ...
+
+def namespace(ns: typing.Optional[str]) -> typing.Optional[str]:
+    """
+    Switch namespace to the one provided.
+    
+    This call has a global effect. No objects outside this namespace
+    will be accessible. To access all objects regardless of namespaces,
+    pass None to this call.
+    
+    Parameters
+    ----------
+    ns : str, optional
+        Namespace to switch to or None to ignore namespaces.
+    
+    Returns
+    -------
+    str, optional
+        Namespace set (result of get_namespace()).
+    """
+    ...
+
+def get_namespace() -> typing.Optional[str]:
+    """
+    Return the current namespace that is currently being used to filter objects.
+    
+    The namespace is a tag associated with all objects in Metaflow.
+    
+    Returns
+    -------
+    str, optional
+        The current namespace used to filter objects.
+    """
+    ...
+
+def default_namespace() -> str:
+    """
+    Resets the namespace used to filter objects to the default one, i.e. the one that was
+    used prior to any `namespace` calls.
+    
+    Returns
+    -------
+    str
+        The result of get_namespace() after the namespace has been reset.
+    """
+    ...
+
+def get_metadata() -> str:
+    """
+    Returns the current Metadata provider.
+    
+    If this is not set explicitly using `metadata`, the default value is
+    determined through the Metaflow configuration. You can use this call to
+    check that your configuration is set up properly.
+    
+    If multiple configuration profiles are present, this call returns the one
+    selected through the `METAFLOW_PROFILE` environment variable.
+    
+    Returns
+    -------
+    str
+        Information about the Metadata provider currently selected. This information typically
+        returns provider specific information (like URL for remote providers or local paths for
+        local providers).
+    """
+    ...
+
+def default_metadata() -> str:
+    """
+    Resets the Metadata provider to the default value, that is, to the value
+    that was used prior to any `metadata` calls.
+    
+    Returns
+    -------
+    str
+        The result of get_metadata() after resetting the provider.
+    """
+    ...
+
+class Metaflow(object, metaclass=type):
+    def __init__(self):
+        ...
+    @property
+    def flows(self) -> typing.List[metaflow.client.core.Flow]:
+        """
+        Returns a list of all the flows present.
+        
+        Only flows present in the set namespace are returned. A flow is present in a namespace if
+        it has at least one run that is in the namespace.
+        
+        Returns
+        -------
+        List[Flow]
+            List of all flows present.
+        """
+        ...
+    def __iter__(self) -> typing.Iterator[metaflow.client.core.Flow]:
+        """
+        Iterator over all flows present.
+        
+        Only flows present in the set namespace are returned. A flow is present in a
+        namespace if it has at least one run that is in the namespace.
+        
+        Yields
+        -------
+        Flow
+            A Flow present in the Metaflow universe.
+        """
+        ...
+    def __str__(self) -> str:
+        ...
+    def __getitem__(self, name: str) -> metaflow.client.core.Flow:
+        """
+        Returns a specific flow by name.
+        
+        The flow will only be returned if it is present in the current namespace.
+        
+        Parameters
+        ----------
+        name : str
+            Name of the Flow
+        
+        Returns
+        -------
+        Flow
+            Flow with the given name.
+        """
+        ...
+    ...
+
+class Flow(metaflow.client.core.MetaflowObject, metaclass=type):
+    def __init__(self, *args, **kwargs):
+        ...
+    @property
+    def latest_run(self) -> typing.Optional[metaflow.client.core.Run]:
+        """
+        Returns the latest run (either in progress or completed) of this flow.
+        
+        Note that an in-progress run may be returned by this call. Use latest_successful_run
+        to get an object representing a completed successful run.
+        
+        Returns
+        -------
+        Run, optional
+            Latest run of this flow
+        """
+        ...
+    @property
+    def latest_successful_run(self) -> typing.Optional[metaflow.client.core.Run]:
+        """
+        Returns the latest successful run of this flow.
+        
+        Returns
+        -------
+        Run, optional
+            Latest successful run of this flow
+        """
+        ...
+    def runs(self, *tags: str) -> typing.Iterator[metaflow.client.core.Run]:
+        """
+        Returns an iterator over all `Run`s of this flow.
+        
+        An optional filter is available that allows you to filter on tags.
+        If multiple tags are specified, only runs that have all the
+        specified tags are returned.
+        
+        Parameters
+        ----------
+        tags : str
+            Tags to match.
+        
+        Yields
+        ------
+        Run
+            `Run` objects in this flow.
+        """
+        ...
+    def __iter__(self) -> typing.Iterator[metaflow.client.core.Task]:
+        """
+        Iterate over all children Run of this Flow.
+        
+        Note that only runs in the current namespace are returned unless
+        _namespace_check is False
+        
+        Yields
+        ------
+        Run
+            A Run in this Flow
+        """
+        ...
+    def __getitem__(self, run_id: str) -> metaflow.client.core.Run:
+        """
+        Returns the Run object with the run ID 'run_id'
+        
+        Parameters
+        ----------
+        run_id : str
+            Run OD
+        
+        Returns
+        -------
+        Run
+            Run for this run ID in this Flow
+        
+        Raises
+        ------
+        KeyError
+            If the run_id does not identify a valid Run object
+        """
+        ...
+    def __getstate__(self):
+        ...
+    def __setstate__(self, state):
+        ...
+    ...
+
+class Run(metaflow.client.core.MetaflowObject, metaclass=type):
+    def steps(self, *tags: str) -> typing.Iterator[metaflow.client.core.Step]:
+        """
+        [Legacy function - do not use]
+        
+        Returns an iterator over all `Step` objects in the step. This is an alias
+        to iterating the object itself, i.e.
+        ```
+        list(Run(...)) == list(Run(...).steps())
+        ```
+        
+        Parameters
+        ----------
+        tags : str
+            No op (legacy functionality)
+        
+        Yields
+        ------
+        Step
+            `Step` objects in this run.
+        """
+        ...
+    @property
+    def code(self) -> typing.Optional[metaflow.client.core.MetaflowCode]:
+        """
+        Returns the MetaflowCode object for this run, if present.
+        Code is packed if atleast one `Step` runs remotely, else None is returned.
+        
+        Returns
+        -------
+        MetaflowCode, optional
+            Code package for this run
+        """
+        ...
+    @property
+    def data(self) -> typing.Optional[metaflow.client.core.MetaflowData]:
+        """
+        Returns a container of data artifacts produced by this run.
+        
+        You can access data produced by this run as follows:
+        ```
+        print(run.data.my_var)
+        ```
+        This is a shorthand for `run['end'].task.data`. If the 'end' step has not yet
+        executed, returns None.
+        
+        Returns
+        -------
+        MetaflowData, optional
+            Container of all artifacts produced by this task
+        """
+        ...
+    @property
+    def successful(self) -> bool:
+        """
+        Indicates whether or not the run completed successfully.
+        
+        A run is successful if its 'end' step is successful.
+        
+        Returns
+        -------
+        bool
+            True if the run completed successfully and False otherwise
+        """
+        ...
+    @property
+    def finished(self) -> bool:
+        """
+        Indicates whether or not the run completed.
+        
+        A run completed if its 'end' step completed.
+        
+        Returns
+        -------
+        bool
+            True if the run completed and False otherwise
+        """
+        ...
+    @property
+    def finished_at(self) -> typing.Optional[datetime.datetime]:
+        """
+        Returns the datetime object of when the run finished (successfully or not).
+        
+        The completion time of a run is the same as the completion time of its 'end' step.
+        If the 'end' step has not completed, returns None.
+        
+        Returns
+        -------
+        datetime, optional
+            Datetime of when the run finished
+        """
+        ...
+    @property
+    def end_task(self) -> typing.Optional[metaflow.client.core.Task]:
+        """
+        Returns the Task corresponding to the 'end' step.
+        
+        This returns None if the end step does not yet exist.
+        
+        Returns
+        -------
+        Task, optional
+            The 'end' task
+        """
+        ...
+    def add_tag(self, tag: str):
+        """
+        Add a tag to this `Run`.
+        
+        Note that if the tag is already a system tag, it is not added as a user tag,
+        and no error is thrown.
+        
+        Parameters
+        ----------
+        tag : str
+            Tag to add.
+        """
+        ...
+    def add_tags(self, tags: typing.Iterable[str]):
+        """
+        Add one or more tags to this `Run`.
+        
+        Note that if any tag is already a system tag, it is not added as a user tag
+        and no error is thrown.
+        
+        Parameters
+        ----------
+        tags : Iterable[str]
+            Tags to add.
+        """
+        ...
+    def remove_tag(self, tag: str):
+        """
+        Remove one tag from this `Run`.
+        
+        Removing a system tag is an error. Removing a non-existent
+        user tag is a no-op.
+        
+        Parameters
+        ----------
+        tag : str
+            Tag to remove.
+        """
+        ...
+    def remove_tags(self, tags: typing.Iterable[str]):
+        """
+        Remove one or more tags to this `Run`.
+        
+        Removing a system tag will result in an error. Removing a non-existent
+        user tag is a no-op.
+        
+        Parameters
+        ----------
+        tags : Iterable[str]
+            Tags to remove.
+        """
+        ...
+    def replace_tag(self, tag_to_remove: str, tag_to_add: str):
+        """
+        Remove a tag and add a tag atomically. Removal is done first.
+        The rules for `Run.add_tag` and `Run.remove_tag` also apply here.
+        
+        Parameters
+        ----------
+        tag_to_remove : str
+            Tag to remove.
+        tag_to_add : str
+            Tag to add.
+        """
+        ...
+    def replace_tags(self, tags_to_remove: typing.Iterable[str], tags_to_add: typing.Iterable[str]):
+        """
+        Remove and add tags atomically; the removal is done first.
+        The rules for `Run.add_tag` and `Run.remove_tag` also apply here.
+        
+        Parameters
+        ----------
+        tags_to_remove : Iterable[str]
+            Tags to remove.
+        tags_to_add : Iterable[str]
+            Tags to add.
+        """
+        ...
+    def __iter__(self) -> typing.Iterator[metaflow.client.core.Step]:
+        """
+        Iterate over all children Step of this Run
+        
+        Yields
+        ------
+        Step
+            A Step in this Run
+        """
+        ...
+    def __getitem__(self, name: str) -> metaflow.client.core.Step:
+        """
+        Returns the Step object with the step name 'name'
+        
+        Parameters
+        ----------
+        name : str
+            Step name
+        
+        Returns
+        -------
+        Step
+            Step for this step name in this Run
+        
+        Raises
+        ------
+        KeyError
+            If the name does not identify a valid Step object
+        """
+        ...
+    def __getstate__(self):
+        ...
+    def __setstate__(self, state):
+        ...
+    @property
+    def trigger(self) -> typing.Optional[metaflow.events.Trigger]:
+        """
+        Returns a container of events that triggered this run.
+        
+        This returns None if the run was not triggered by any events.
+        
+        Returns
+        -------
+        Trigger, optional
+            Container of triggering events
+        """
+        ...
+    ...
+
+class Step(metaflow.client.core.MetaflowObject, metaclass=type):
+    @property
+    def task(self) -> typing.Optional[metaflow.client.core.Task]:
+        """
+        Returns a Task object belonging to this step.
+        
+        This is useful when the step only contains one task (a linear step for example).
+        
+        Returns
+        -------
+        Task
+            A task in the step
+        """
+        ...
+    def tasks(self, *tags: str) -> typing.Iterable[metaflow.client.core.Task]:
+        """
+        [Legacy function - do not use]
+        
+        Returns an iterator over all `Task` objects in the step. This is an alias
+        to iterating the object itself, i.e.
+        ```
+        list(Step(...)) == list(Step(...).tasks())
+        ```
+        
+        Parameters
+        ----------
+        tags : str
+            No op (legacy functionality)
+        
+        Yields
+        ------
+        Task
+            `Task` objects in this step.
+        """
+        ...
+    @property
+    def control_task(self) -> typing.Optional[metaflow.client.core.Task]:
+        """
+        [Unpublished API - use with caution!]
+        
+        Returns a Control Task object belonging to this step.
+        This is useful when the step only contains one control task.
+        
+        Returns
+        -------
+        Task
+            A control task in the step
+        """
+        ...
+    def control_tasks(self, *tags: str) -> typing.Iterator[metaflow.client.core.Task]:
+        """
+        [Unpublished API - use with caution!]
+        
+        Returns an iterator over all the control tasks in the step.
+        An optional filter is available that allows you to filter on tags. The
+        control tasks returned if the filter is specified will contain all the
+        tags specified.
+        Parameters
+        ----------
+        tags : str
+            Tags to match
+        
+        Yields
+        ------
+        Task
+            Control Task objects for this step
+        """
+        ...
+    def __iter__(self) -> typing.Iterator[metaflow.client.core.Task]:
+        """
+        Iterate over all children Task of this Step
+        
+        Yields
+        ------
+        Task
+            A Task in this Step
+        """
+        ...
+    def __getitem__(self, task_id: str) -> metaflow.client.core.Task:
+        """
+        Returns the Task object with the task ID 'task_id'
+        
+        Parameters
+        ----------
+        task_id : str
+            Task ID
+        
+        Returns
+        -------
+        Task
+            Task for this task ID in this Step
+        
+        Raises
+        ------
+        KeyError
+            If the task_id does not identify a valid Task object
+        """
+        ...
+    def __getstate__(self):
+        ...
+    def __setstate__(self, state):
+        ...
+    @property
+    def finished_at(self) -> typing.Optional[datetime.datetime]:
+        """
+        Returns the datetime object of when the step finished (successfully or not).
+        
+        A step is considered finished when all the tasks that belong to it have
+        finished. This call will return None if the step has not finished
+        
+        Returns
+        -------
+        datetime
+            Datetime of when the step finished
+        """
+        ...
+    @property
+    def environment_info(self) -> typing.Optional[typing.Dict[str, typing.Any]]:
+        """
+        Returns information about the environment that was used to execute this step. As an
+        example, if the Conda environment is selected, this will return information about the
+        dependencies that were used in the environment.
+        
+        This environment information is only available for steps that have tasks
+        for which the code package has been saved.
+        
+        Returns
+        -------
+        Dict[str, Any], optional
+            Dictionary describing the environment
+        """
+        ...
+    ...
+
+class Task(metaflow.client.core.MetaflowObject, metaclass=type):
+    def __init__(self, *args, **kwargs):
+        ...
+    @property
+    def metadata(self) -> typing.List[metaflow.client.core.Metadata]:
+        """
+        Metadata events produced by this task across all attempts of the task
+        *except* if you selected a specific task attempt.
+        
+        Note that Metadata is different from tags.
+        
+        Returns
+        -------
+        List[Metadata]
+            Metadata produced by this task
+        """
+        ...
+    @property
+    def metadata_dict(self) -> typing.Dict[str, str]:
+        """
+        Dictionary mapping metadata names (keys) and their associated values.
+        
+        Note that unlike the metadata() method, this call will only return the latest
+        metadata for a given name. For example, if a task executes multiple times (retries),
+        the same metadata name will be generated multiple times (one for each execution of the
+        task). The metadata() method returns all those metadata elements whereas this call will
+        return the metadata associated with the latest execution of the task.
+        
+        Returns
+        -------
+        Dict[str, str]
+            Dictionary mapping metadata name with value
+        """
+        ...
+    @property
+    def index(self) -> typing.Optional[int]:
+        """
+        Returns the index of the innermost foreach loop if this task is run inside at least
+        one foreach.
+        
+        The index is what distinguishes the various tasks inside a given step.
+        This call returns None if this task was not run in a foreach loop.
+        
+        Returns
+        -------
+        int, optional
+            Index in the innermost loop for this task
+        """
+        ...
+    @property
+    def data(self) -> metaflow.client.core.MetaflowData:
+        """
+        Returns a container of data artifacts produced by this task.
+        
+        You can access data produced by this task as follows:
+        ```
+        print(task.data.my_var)
+        ```
+        
+        Returns
+        -------
+        MetaflowData
+            Container of all artifacts produced by this task
+        """
+        ...
+    @property
+    def artifacts(self) -> typing.NamedTuple:
+        """
+        Returns a container of DataArtifacts produced by this task.
+        
+        You can access each DataArtifact by name like so:
+        ```
+        print(task.artifacts.my_var)
+        ```
+        This method differs from data() because it returns DataArtifact objects
+        (which contain additional metadata) as opposed to just the data.
+        
+        Returns
+        -------
+        MetaflowArtifacts
+            Container of all DataArtifacts produced by this task
+        """
+        ...
+    @property
+    def successful(self) -> bool:
+        """
+        Indicates whether or not the task completed successfully.
+        
+        This information is always about the latest task to have completed (in case
+        of retries).
+        
+        Returns
+        -------
+        bool
+            True if the task completed successfully and False otherwise
+        """
+        ...
+    @property
+    def finished(self) -> bool:
+        """
+        Indicates whether or not the task completed.
+        
+        This information is always about the latest task to have completed (in case
+        of retries).
+        
+        Returns
+        -------
+        bool
+            True if the task completed and False otherwise
+        """
+        ...
+    @property
+    def exception(self) -> typing.Optional[typing.Any]:
+        """
+        Returns the exception that caused the task to fail, if any.
+        
+        This information is always about the latest task to have completed (in case
+        of retries). If successful() returns False and finished() returns True,
+        this method can help determine what went wrong.
+        
+        Returns
+        -------
+        object
+            Exception raised by the task or None if not applicable
+        """
+        ...
+    @property
+    def finished_at(self) -> typing.Optional[datetime.datetime]:
+        """
+        Returns the datetime object of when the task finished (successfully or not).
+        
+        This information is always about the latest task to have completed (in case
+        of retries). This call will return None if the task is not finished.
+        
+        Returns
+        -------
+        datetime
+            Datetime of when the task finished
+        """
+        ...
+    @property
+    def runtime_name(self) -> typing.Optional[str]:
+        """
+        Returns the name of the runtime this task executed on.
+        
+        
+        Returns
+        -------
+        str
+            Name of the runtime this task executed on
+        """
+        ...
+    @property
+    def stdout(self) -> str:
+        """
+        Returns the full standard out of this task.
+        
+        If you specify a specific attempt for this task, it will return the
+        standard out for that attempt. If you do not specify an attempt,
+        this will return the current standard out for the latest *started*
+        attempt of the task. In both cases, multiple calls to this
+        method will return the most up-to-date log (so if an attempt is not
+        done, each call will fetch the latest log).
+        
+        Returns
+        -------
+        str
+            Standard output of this task
+        """
+        ...
+    @property
+    def stdout_size(self) -> int:
+        """
+        Returns the size of the stdout log of this task.
+        
+        Similar to `stdout`, the size returned is the latest size of the log
+        (so for a running attempt, this value will increase as the task produces
+        more output).
+        
+        Returns
+        -------
+        int
+            Size of the stdout log content (in bytes)
+        """
+        ...
+    @property
+    def stderr(self) -> str:
+        """
+        Returns the full standard error of this task.
+        
+        If you specify a specific attempt for this task, it will return the
+        standard error for that attempt. If you do not specify an attempt,
+        this will return the current standard error for the latest *started*
+        attempt. In both cases, multiple calls to this
+        method will return the most up-to-date log (so if an attempt is not
+        done, each call will fetch the latest log).
+        
+        Returns
+        -------
+        str
+            Standard error of this task
+        """
+        ...
+    @property
+    def stderr_size(self) -> int:
+        """
+        Returns the size of the stderr log of this task.
+        
+        Similar to `stderr`, the size returned is the latest size of the log
+        (so for a running attempt, this value will increase as the task produces
+        more output).
+        
+        Returns
+        -------
+        int
+            Size of the stderr log content (in bytes)
+        """
+        ...
+    @property
+    def current_attempt(self) -> int:
+        """
+        Get the relevant attempt for this Task.
+        
+        Returns the specific attempt used when
+        initializing the instance, or the latest *started* attempt for the Task.
+        
+        Returns
+        -------
+        int
+            attempt id for this task object
+        """
+        ...
+    @property
+    def code(self) -> typing.Optional[metaflow.client.core.MetaflowCode]:
+        """
+        Returns the MetaflowCode object for this task, if present.
+        
+        Not all tasks save their code so this call may return None in those cases.
+        
+        Returns
+        -------
+        MetaflowCode
+            Code package for this task
+        """
+        ...
+    @property
+    def environment_info(self) -> typing.Dict[str, typing.Any]:
+        """
+        Returns information about the environment that was used to execute this task. As an
+        example, if the Conda environment is selected, this will return information about the
+        dependencies that were used in the environment.
+        
+        This environment information is only available for tasks that have a code package.
+        
+        Returns
+        -------
+        Dict
+            Dictionary describing the environment
+        """
+        ...
+    def loglines(self, stream: str, as_unicode: bool = True, meta_dict: typing.Optional[typing.Dict[str, typing.Any]] = None) -> typing.Iterator[typing.Tuple[datetime.datetime, str]]:
+        """
+        Return an iterator over (utc_timestamp, logline) tuples.
+        
+        Parameters
+        ----------
+        stream : str
+            Either 'stdout' or 'stderr'.
+        as_unicode : bool, default: True
+            If as_unicode=False, each logline is returned as a byte object. Otherwise,
+            it is returned as a (unicode) string.
+        
+        Yields
+        ------
+        Tuple[datetime, str]
+            Tuple of timestamp, logline pairs.
+        """
+        ...
+    def __iter__(self) -> typing.Iterator[metaflow.client.core.DataArtifact]:
+        """
+        Iterate over all children DataArtifact of this Task
+        
+        Yields
+        ------
+        DataArtifact
+            A DataArtifact in this Step
+        """
+        ...
+    def __getitem__(self, name: str) -> metaflow.client.core.DataArtifact:
+        """
+        Returns the DataArtifact object with the artifact name 'name'
+        
+        Parameters
+        ----------
+        name : str
+            Data artifact name
+        
+        Returns
+        -------
+        DataArtifact
+            DataArtifact for this artifact name in this task
+        
+        Raises
+        ------
+        KeyError
+            If the name does not identify a valid DataArtifact object
+        """
+        ...
+    def __getstate__(self):
+        ...
+    def __setstate__(self, state):
+        ...
+    ...
+
+class DataArtifact(metaflow.client.core.MetaflowObject, metaclass=type):
+    @property
+    def data(self) -> typing.Any:
+        """
+        Unpickled representation of the data contained in this artifact.
+        
+        Returns
+        -------
+        object
+            Object contained in this artifact
+        """
+        ...
+    @property
+    def size(self) -> int:
+        """
+        Returns the size (in bytes) of the pickled object representing this
+        DataArtifact
+        
+        Returns
+        -------
+        int
+            size of the pickled representation of data artifact (in bytes)
+        """
+        ...
+    @property
+    def sha(self) -> str:
+        """
+        Unique identifier for this artifact.
+        
+        This is a unique hash of the artifact (historically SHA1 hash)
+        
+        Returns
+        -------
+        str
+            Hash of this artifact
+        """
+        ...
+    @property
+    def finished_at(self) -> datetime.datetime:
+        """
+        Creation time for this artifact.
+        
+        Alias for created_at.
+        
+        Returns
+        -------
+        datetime
+            Creation time
+        """
+        ...
+    def __getstate__(self):
+        ...
+    def __setstate__(self, state):
+        ...
+    ...
+