ob-metaflow-stubs 6.0.3.123__py2.py3-none-any.whl → 6.0.3.126__py2.py3-none-any.whl

metaflow-stubs/user_configs/config_decorators.pyi

@@ -0,0 +1,253 @@
+######################################################################################################
+#                                 Auto-generated Metaflow stub file                                  #
+# MF version: 2.12.39.1+obcheckpoint(0.1.4);ob(v1)                                                   #
+# Generated on 2024-12-17T01:10:55.769764                                                            #
+######################################################################################################
+
+from __future__ import annotations
+
+import typing
+if typing.TYPE_CHECKING:
+    import metaflow.user_configs.config_decorators
+    import metaflow.flowspec
+    import metaflow.user_configs.config_parameters
+    import metaflow.parameters
+    import typing
+    import metaflow.decorators
+    import functools
+
+from ..exception import MetaflowException as MetaflowException
+from .config_parameters import ConfigValue as ConfigValue
+from .config_parameters import resolve_delayed_evaluator as resolve_delayed_evaluator
+
+TYPE_CHECKING: bool
+
+class MutableStep(object, metaclass=type):
+    """
+    A MutableStep is a wrapper passed to the `CustomStepDecorator`'s `evaluate` method
+    to allow the decorator to interact with the step and providing easy methods to
+    modify the behavior of the step.
+    """
+    def __init__(self, flow_spec: "metaflow.flowspec.FlowSpec", step: typing.Union[typing.Callable[["metaflow.decorators.FlowSpecDerived"], None], typing.Callable[["metaflow.decorators.FlowSpecDerived", typing.Any], None]]):
+        ...
+    @property
+    def flow(self) -> MutableFlow:
+        """
+        The flow that contains this step
+        
+        Returns
+        -------
+        MutableFlow
+            The flow that contains this step
+        """
+        ...
+    @property
+    def decorators(self) -> typing.Generator["metaflow.decorators.StepDecorator", None, None]:
+        """
+        Iterate over all the decorators of this step. Note that the same type of decorator
+        may be present multiple times and no order is guaranteed.
+        
+        Yields
+        ------
+        metaflow.decorators.StepDecorator
+            A decorator of the step
+        """
+        ...
+    def add_decorator(self, deco_type: functools.partial, **kwargs):
+        """
+        Add a Metaflow decorator to a step.
+        
+        Parameters
+        ----------
+        deco_type : partial
+            The decorator class to add to this step
+        """
+        ...
+    def remove_decorator(self, deco_name: str, all: bool = True, **kwargs) -> bool:
+        """
+        Remove one or more Metaflow decorators from a step.
+        
+        Some decorators can be applied multiple times to a step. This method allows you
+        to choose which decorator to remove or just remove all of them or one of them.
+        
+        Parameters
+        ----------
+        deco_name : str
+            Name of the decorator to remove
+        all : bool, default True
+            If True, remove all instances of the decorator that match the filters
+            passed using kwargs (or all the instances of the decorator if no filters are
+            passed). If False, removes only the first found instance of the decorator.
+        
+        Returns
+        -------
+        bool
+            Returns True if at least one decorator was removed.
+        """
+        ...
+    ...
+
+class MutableFlow(object, metaclass=type):
+    def __init__(self, flow_spec: "metaflow.flowspec.FlowSpec"):
+        ...
+    @property
+    def decorators(self) -> typing.Generator["metaflow.decorators.FlowDecorator", None, None]:
+        """
+        Iterate over all the decorators of this flow. Note that the same type of decorator
+        may be present multiple times and no order is guaranteed.
+        
+        Yields
+        ------
+        metaflow.decorators.FlowDecorator
+            A decorator of the flow
+        """
+        ...
+    @property
+    def configs(self) -> typing.Generator[typing.Tuple[str, metaflow.user_configs.config_parameters.ConfigValue], None, None]:
+        """
+        Iterate over all user configurations in this flow
+        
+        Use this to parameterize your flow based on configuration. As an example, the
+        `evaluate` method of your `CustomFlowDecorator` can use this to add an
+        environment decorator.
+        ```
+        class MyDecorator(CustomFlowDecorator):
+            def evaluate(flow: MutableFlow):
+                val = next(flow.configs)[1].steps.start.cpu
+                flow.start.add_decorator(environment, vars={'mycpu': val})
+                return flow
+        
+        @MyDecorator()
+        class TestFlow(FlowSpec):
+            config = Config('myconfig.json')
+        
+            @step
+            def start(self):
+                pass
+        ```
+        can be used to add an environment decorator to the `start` step.
+        
+        Yields
+        ------
+        Tuple[str, ConfigValue]
+            Iterates over the configurations of the flow
+        """
+        ...
+    @property
+    def parameters(self) -> typing.Generator[typing.Tuple[str, typing.Any], None, None]:
+        ...
+    @property
+    def steps(self) -> typing.Generator[typing.Tuple[str, MutableStep], None, None]:
+        """
+        Iterate over all the steps in this flow. The order of the steps
+        returned is not guaranteed.
+        
+        Yields
+        ------
+        Tuple[str, MutableStep]
+            A tuple with the step name and the step proxy
+        """
+        ...
+    def add_parameter(self, name: str, value: "metaflow.parameters.Parameter", overwrite: bool = False):
+        ...
+    def remove_parameter(self, parameter_name: str) -> bool:
+        """
+        Remove a parameter from the flow.
+        
+        The name given should match the name of the parameter (can be different
+        from the name of the parameter in the flow. You can not remove config parameters.
+        
+        Parameters
+        ----------
+        parameter_name : str
+            Name of the parameter
+        
+        Returns
+        -------
+        bool
+            Returns True if the parameter was removed
+        """
+        ...
+    def add_decorator(self, deco_type: functools.partial, **kwargs):
+        """
+        Add a Metaflow decorator to a flow.
+        
+        Parameters
+        ----------
+        deco_type : partial
+            The decorator class to add to this flow
+        """
+        ...
+    def remove_decorator(self, deco_name: str, all: bool = True, **kwargs) -> bool:
+        """
+        Remove one or more Metaflow decorators from a flow.
+        
+        Some decorators can be applied multiple times to a flow. This method allows you
+        to choose which decorator to remove or just remove all of them or one of them.
+        
+        Parameters
+        ----------
+        deco_name : str
+            Name of the decorator to remove
+        all : bool, default True
+            If True, remove all instances of the decorator that match the filters
+            passed using kwargs (or all the instances of the decorator if no filters are
+            passed). If False, removes only the first found instance of the decorator.
+        
+        Returns
+        -------
+        bool
+            Returns True if at least one decorator was removed.
+        """
+        ...
+    def __getattr__(self, name):
+        ...
+    ...
+
+class CustomFlowDecorator(object, metaclass=type):
+    def __init__(self, *args, **kwargs):
+        ...
+    def __get__(self, instance, owner):
+        ...
+    def __call__(self, flow_spec: typing.Optional["metaflow.flowspec.FlowSpecMeta"] = None) -> "metaflow.flowspec.FlowSpecMeta":
+        ...
+    def init(self, *args, **kwargs):
+        """
+        This method is intended to be optionally overridden if you need to
+        have an initializer.
+        """
+        ...
+    def evaluate(self, mutable_flow: MutableFlow):
+        """
+        Implement this method to act on the flow and modify it as needed.
+        
+        Parameters
+        ----------
+        mutable_flow : MutableFlow
+            Flow
+        
+        Raises
+        ------
+        NotImplementedError
+            _description_
+        """
+        ...
+    ...
+
+class CustomStepDecorator(object, metaclass=type):
+    def __init__(self, *args, **kwargs):
+        ...
+    def __get__(self, instance, owner):
+        ...
+    def __call__(self, step: typing.Union[typing.Callable[["metaflow.decorators.FlowSpecDerived"], None], typing.Callable[["metaflow.decorators.FlowSpecDerived", typing.Any], None], None] = None) -> typing.Union[typing.Callable[["metaflow.decorators.FlowSpecDerived"], None], typing.Callable[["metaflow.decorators.FlowSpecDerived", typing.Any], None]]:
+        ...
+    def init(self, *args, **kwargs):
+        """
+        This method is intended to be optionally overridden if you need to
+        have an initializer.
+        """
+        ...
+    def evaluate(self, mutable_step: MutableStep):
+        ...
+    ...
+

metaflow-stubs/user_configs/config_options.pyi

@@ -0,0 +1,82 @@
+######################################################################################################
+#                                 Auto-generated Metaflow stub file                                  #
+# MF version: 2.12.39.1+obcheckpoint(0.1.4);ob(v1)                                                   #
+# Generated on 2024-12-17T01:10:55.785989                                                            #
+######################################################################################################
+
+from __future__ import annotations
+
+import typing
+import metaflow
+if typing.TYPE_CHECKING:
+    import typing
+    import metaflow._vendor.click.types
+
+from .._vendor import click as click
+from .config_parameters import ConfigValue as ConfigValue
+from ..exception import MetaflowException as MetaflowException
+from ..exception import MetaflowInternalError as MetaflowInternalError
+from ..parameters import DeployTimeField as DeployTimeField
+from ..parameters import ParameterContext as ParameterContext
+
+CONFIG_FILE: str
+
+class ConvertPath(metaflow._vendor.click.types.Path, metaclass=type):
+    def convert(self, value, param, ctx):
+        ...
+    @staticmethod
+    def mark_as_default(value):
+        ...
+    @staticmethod
+    def convert_value(value, is_default):
+        ...
+    ...
+
+class ConvertDictOrStr(metaflow._vendor.click.types.ParamType, metaclass=type):
+    def convert(self, value, param, ctx):
+        ...
+    @staticmethod
+    def convert_value(value, is_default):
+        ...
+    @staticmethod
+    def mark_as_default(value):
+        ...
+    ...
+
+class MultipleTuple(metaflow._vendor.click.types.Tuple, metaclass=type):
+    def split_envvar_value(self, rv):
+        ...
+    ...
+
+class ConfigInput(object, metaclass=type):
+    def __init__(self, req_configs: typing.List[str], defaults: typing.Dict[str, typing.Tuple[typing.Union[str, typing.Dict[typing.Any, typing.Any]], bool]], parsers: typing.Dict[str, typing.Union[str, typing.Callable[[str], typing.Dict[typing.Any, typing.Any]]]]):
+        ...
+    @staticmethod
+    def make_key_name(name: str) -> str:
+        ...
+    @classmethod
+    def set_config_file(cls, config_file: str):
+        ...
+    @classmethod
+    def get_config(cls, config_name: str) -> typing.Optional[typing.Dict[typing.Any, typing.Any]]:
+        ...
+    def process_configs(self, ctx, param, value):
+        ...
+    def __str__(self):
+        ...
+    def __repr__(self):
+        ...
+    ...
+
+class LocalFileInput(metaflow._vendor.click.types.Path, metaclass=type):
+    def convert(self, value, param, ctx):
+        ...
+    def __str__(self):
+        ...
+    def __repr__(self):
+        ...
+    ...
+
+def config_options(cmd):
+    ...
+

metaflow-stubs/user_configs/config_parameters.pyi

@@ -0,0 +1,217 @@
+######################################################################################################
+#                                 Auto-generated Metaflow stub file                                  #
+# MF version: 2.12.39.1+obcheckpoint(0.1.4);ob(v1)                                                   #
+# Generated on 2024-12-17T01:10:55.768336                                                            #
+######################################################################################################
+
+from __future__ import annotations
+
+import collections
+import typing
+import metaflow
+import abc
+if typing.TYPE_CHECKING:
+    import abc
+    import collections.abc
+    import metaflow.user_configs.config_parameters
+    import metaflow.parameters
+    import typing
+
+from ..exception import MetaflowException as MetaflowException
+from ..parameters import Parameter as Parameter
+from ..parameters import ParameterContext as ParameterContext
+
+TYPE_CHECKING: bool
+
+CONFIG_FILE: str
+
+UNPACK_KEY: str
+
+def dump_config_values(flow: "FlowSpec"):
+    ...
+
+class ConfigValue(collections.abc.Mapping, metaclass=abc.ABCMeta):
+    """
+    ConfigValue is a thin wrapper around an arbitrarily nested dictionary-like
+    configuration object. It allows you to access elements of this nested structure
+    using either a "." notation or a [] notation. As an example, if your configuration
+    object is:
+    {"foo": {"bar": 42}}
+    you can access the value 42 using either config["foo"]["bar"] or config.foo.bar.
+    
+    All "keys"" need to be valid Python identifiers
+    """
+    def __init__(self, data: typing.Dict[str, typing.Any]):
+        ...
+    def __getattr__(self, key: str) -> typing.Any:
+        """
+        Access an element of this configuration
+        
+        Parameters
+        ----------
+        key : str
+            Element to access
+        
+        Returns
+        -------
+        Any
+            Element of the configuration
+        """
+        ...
+    def __setattr__(self, name: str, value: typing.Any):
+        ...
+    def __getitem__(self, key: typing.Any) -> typing.Any:
+        """
+        Access an element of this configuration
+        
+        Parameters
+        ----------
+        key : Any
+            Element to access
+        
+        Returns
+        -------
+        Any
+            Element of the configuration
+        """
+        ...
+    def __len__(self):
+        ...
+    def __iter__(self):
+        ...
+    def __repr__(self):
+        ...
+    def __str__(self):
+        ...
+    def to_dict(self) -> typing.Dict[typing.Any, typing.Any]:
+        """
+        Returns a dictionary representation of this configuration object.
+        
+        Returns
+        -------
+        Dict[Any, Any]
+            Dictionary equivalent of this configuration object.
+        """
+        ...
+    ...
+
+class DelayEvaluator(collections.abc.Mapping, metaclass=abc.ABCMeta):
+    """
+    Small wrapper that allows the evaluation of a Config() value in a delayed manner.
+    This is used when we want to use config.* values in decorators for example.
+    
+    It also allows the following "delayed" access on an obj that is a DelayEvaluation
+      - obj.x.y.z (ie: accessing members of DelayEvaluator; accesses will be delayed until
+        the DelayEvaluator is evaluated)
+      - **obj (ie: unpacking the DelayEvaluator as a dictionary). Note that this requires
+        special handling in whatever this is being unpacked into, specifically the handling
+        of _unpacked_delayed_*
+    """
+    def __init__(self, ex: str):
+        ...
+    def __iter__(self):
+        ...
+    def __getitem__(self, key):
+        ...
+    def __len__(self):
+        ...
+    def __getattr__(self, name):
+        ...
+    def __call__(self, ctx = None, deploy_time = False):
+        ...
+    ...
+
+def config_expr(expr: str) -> DelayEvaluator:
+    """
+    Function to allow you to use an expression involving a config parameter in
+    places where it may not be directory accessible or if you want a more complicated
+    expression than just a single variable.
+    
+    You can use it as follows:
+      - When the config is not directly accessible:
+    
+            @project(name=config_expr("config").project.name)
+            class MyFlow(FlowSpec):
+                config = Config("config")
+                ...
+      - When you want a more complex expression:
+            class MyFlow(FlowSpec):
+                config = Config("config")
+    
+                @environment(vars={"foo": config_expr("config.bar.baz.lower()")})
+                @step
+                def start(self):
+                    ...
+    
+    Parameters
+    ----------
+    expr : str
+        Expression using the config values.
+    """
+    ...
+
+class Config(metaflow.parameters.Parameter, collections.abc.Mapping, metaclass=abc.ABCMeta):
+    """
+    Includes a configuration for this flow.
+    
+    `Config` is a special type of `Parameter` but differs in a few key areas:
+      - it is immutable and determined at deploy time (or prior to running if not deploying
+        to a scheduler)
+      - as such, it can be used anywhere in your code including in Metaflow decorators
+    
+    The value of the configuration is determines as follows:
+      - use the user-provided file path or value. It is an error to provide both
+      - if none are present:
+        - if a default file path (default) is provided, attempt to read this file
+            - if the file is present, use that value. Note that the file will be used
+              even if it has an invalid syntax
+            - if the file is not present, and a default value is present, use that
+      - if still None and is required, this is an error.
+    
+    Parameters
+    ----------
+    name : str
+        User-visible configuration name.
+    default : Union[str, Callable[[ParameterContext], str], optional, default None
+        Default path from where to read this configuration. A function implies that the
+        value will be computed using that function.
+        You can only specify default or default_value.
+    default_value : Union[str, Dict[str, Any], Callable[[ParameterContext, Union[str, Dict[str, Any]]], Any], optional, default None
+        Default value for the parameter. A function
+        implies that the value will be computed using that function.
+        You can only specify default or default_value.
+    help : str, optional, default None
+        Help text to show in `run --help`.
+    required : bool, optional, default None
+        Require that the user specified a value for the configuration. Note that if
+        a default is provided, the required flag is ignored. A value of None is
+        equivalent to False.
+    parser : Union[str, Callable[[str], Dict[Any, Any]]], optional, default None
+        If a callable, it is a function that can parse the configuration string
+        into an arbitrarily nested dictionary. If a string, the string should refer to
+        a function (like "my_parser_package.my_parser.my_parser_function") which should
+        be able to parse the configuration string into an arbitrarily nested dictionary.
+        If the name starts with a ".", it is assumed to be relative to "metaflow".
+    show_default : bool, default True
+        If True, show the default value in the help text.
+    """
+    def __init__(self, name: str, default: typing.Union[str, typing.Callable[[metaflow.parameters.ParameterContext], str], None] = None, default_value: typing.Union[str, typing.Dict[str, typing.Any], typing.Callable[[metaflow.parameters.ParameterContext], typing.Union[str, typing.Dict[str, typing.Any]]], None] = None, help: typing.Optional[str] = None, required: typing.Optional[bool] = None, parser: typing.Union[str, typing.Callable[[str], typing.Dict[typing.Any, typing.Any]], None] = None, **kwargs: typing.Dict[str, str]):
+        ...
+    def load_parameter(self, v):
+        ...
+    def __getattr__(self, name):
+        ...
+    def __iter__(self):
+        ...
+    def __len__(self):
+        ...
+    def __getitem__(self, key):
+        ...
+    ...
+
+def resolve_delayed_evaluator(v: typing.Any) -> typing.Any:
+    ...
+
+def unpack_delayed_evaluator(to_unpack: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+    ...
+

{ob_metaflow_stubs-6.0.3.123.dist-info → ob_metaflow_stubs-6.0.3.126.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ob-metaflow-stubs
-Version: 6.0.3.123
+Version: 6.0.3.126
 Summary: Metaflow Stubs: Stubs for the metaflow package
 Author: Netflix, Outerbounds & the Metaflow Community
 Author-email: help@outerbounds.co