ob-metaflow-stubs 6.0.3.117__py2.py3-none-any.whl → 6.0.3.119__py2.py3-none-any.whl

metaflow-stubs/runner/metaflow_runner.pyi

@@ -1,506 +1,21 @@
-##################################################################################
-#                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.27.1+obcheckpoint(0.1.2);ob(v1)                               #
-# Generated on 2024-11-13T19:05:29.365193                                        #
-##################################################################################
+######################################################################################################
+#                                 Auto-generated Metaflow stub file                                  #
+# MF version: 2.12.30.2+obcheckpoint(0.1.4);ob(v1)                                                   #
+# Generated on 2024-11-21T22:12:20.811274                                                            #
+######################################################################################################
 
 from __future__ import annotations
 
 import typing
 if typing.TYPE_CHECKING:
-    import datetime
+    import metaflow.runner.metaflow_runner
     import metaflow.runner.subprocess_manager
     import metaflow.client.core
-    import metaflow.events
-    import metaflow.runner.metaflow_runner
 
-class Run(metaflow.client.core.MetaflowObject, metaclass=type):
-    """
-    A `Run` represents an execution of a `Flow`. It is a container of `Step`s.
-    
-    Attributes
-    ----------
-    data : MetaflowData
-        a shortcut to run['end'].task.data, i.e. data produced by this run.
-    successful : bool
-        True if the run completed successfully.
-    finished : bool
-        True if the run completed.
-    finished_at : datetime
-        Time this run finished.
-    code : MetaflowCode
-        Code package for this run (if present). See `MetaflowCode`.
-    trigger : MetaflowTrigger
-        Information about event(s) that triggered this run (if present). See `MetaflowTrigger`.
-    end_task : Task
-        `Task` for the end step (if it is present already).
-    """
-    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
-        """
-        ...
-    ...
-
-def handle_timeout(tfp_runner_attribute, command_obj: "CommandManager", file_read_timeout: int):
-    """
-    Handle the timeout for a running subprocess command that reads a file
-    and raises an error with appropriate logs if a TimeoutError occurs.
-    
-    Parameters
-    ----------
-    tfp_runner_attribute : NamedTemporaryFile
-        Temporary file that stores runner attribute data.
-    command_obj : CommandManager
-        Command manager object that encapsulates the running command details.
-    file_read_timeout : int
-        Timeout for reading the file.
-    
-    Returns
-    -------
-    str
-        Content read from the temporary file.
-    
-    Raises
-    ------
-    RuntimeError
-        If a TimeoutError occurs, it raises a RuntimeError with the command's
-        stdout and stderr logs.
-    """
-    ...
-
-class CommandManager(object, metaclass=type):
-    """
-    A manager for an individual subprocess.
-    """
-    def __init__(self, command: typing.List[str], env: typing.Optional[typing.Dict[str, str]] = None, cwd: typing.Optional[str] = None):
-        """
-        Create a new CommandManager object.
-        This does not run the process itself but sets it up.
-        
-        Parameters
-        ----------
-        command : List[str]
-            The command to run in List form.
-        env : Optional[Dict[str, str]], default None
-            Environment variables to set for the subprocess; if not specified,
-            the current enviornment variables are used.
-        cwd : Optional[str], default None
-            The directory to run the subprocess in; if not specified, the current
-            directory is used.
-        """
-        ...
-    def __aenter__(self) -> metaflow.runner.subprocess_manager.CommandManager:
-        ...
-    def __aexit__(self, exc_type, exc_value, traceback):
-        ...
-    def wait(self, timeout: typing.Optional[float] = None, stream: typing.Optional[str] = None):
-        """
-        Wait for the subprocess to finish, optionally with a timeout
-        and optionally streaming its output.
-        
-        You can only call `wait` if `async_run` has already been called.
-        
-        Parameters
-        ----------
-        timeout : Optional[float], default None
-            The maximum time to wait for the subprocess to finish.
-            If the timeout is reached, the subprocess is killed.
-        stream : Optional[str], default None
-            If specified, the specified stream is printed to stdout. `stream` can
-            be one of `stdout` or `stderr`.
-        """
-        ...
-    def sync_wait(self):
-        ...
-    def run(self, show_output: bool = False):
-        """
-        Run the subprocess synchronously. This can only be called once.
-        
-        This also waits on the process implicitly.
-        
-        Parameters
-        ----------
-        show_output : bool, default False
-            Suppress the 'stdout' and 'stderr' to the console by default.
-            They can be accessed later by reading the files present in:
-                - self.log_files["stdout"]
-                - self.log_files["stderr"]
-        """
-        ...
-    def async_run(self):
-        """
-        Run the subprocess asynchronously. This can only be called once.
-        
-        Once this is called, you can then wait on the process (using `wait`), stream
-        logs (using `stream_logs`) or kill it (using `kill`).
-        """
-        ...
-    def stream_log(self, stream: str, position: typing.Optional[int] = None, timeout_per_line: typing.Optional[float] = None, log_write_delay: float = 0.01) -> typing.Iterator[typing.Tuple[int, str]]:
-        """
-        Stream logs from the subprocess line by line.
-        
-        Parameters
-        ----------
-        stream : str
-            The stream to stream logs from. Can be one of "stdout" or "stderr".
-        position : Optional[int], default None
-            The position in the log file to start streaming from. If None, it starts
-            from the beginning of the log file. This allows resuming streaming from
-            a previously known position
-        timeout_per_line : Optional[float], default None
-            The time to wait for a line to be read from the log file. If None, it
-            waits indefinitely. If the timeout is reached, a LogReadTimeoutError
-            is raised. Note that this timeout is *per line* and not cumulative so this
-            function may take significantly more time than `timeout_per_line`
-        log_write_delay : float, default 0.01
-            Improves the probability of getting whole lines. This setting is for
-            advanced use cases.
-        
-        Yields
-        ------
-        Tuple[int, str]
-            A tuple containing the position in the log file and the line read. The
-            position returned can be used to feed into another `stream_logs` call
-            for example.
-        """
-        ...
-    def emit_logs(self, stream: str = "stdout", custom_logger: typing.Callable[..., None] = print):
-        """
-        Helper function that can easily emit all the logs for a given stream.
-        
-        This function will only terminate when all the log has been printed.
-        
-        Parameters
-        ----------
-        stream : str, default "stdout"
-            The stream to emit logs for. Can be one of "stdout" or "stderr".
-        custom_logger : Callable[..., None], default print
-            A custom logger function that takes in a string and "emits" it. By default,
-            the log is printed to stdout.
-        """
-        ...
-    def cleanup(self):
-        """
-        Clean up log files for a running subprocesses.
-        """
-        ...
-    def kill(self, termination_timeout: float = 2):
-        """
-        Kill the subprocess and its descendants.
-        
-        Parameters
-        ----------
-        termination_timeout : float, default 2
-            The time to wait after sending a SIGTERM to the process and its descendants
-            before sending a SIGKILL.
-        """
-        ...
-    ...
-
-class SubprocessManager(object, metaclass=type):
-    """
-    A manager for subprocesses. The subprocess manager manages one or more
-    CommandManager objects, each of which manages an individual subprocess.
-    """
-    def __init__(self):
-        ...
-    def __aenter__(self) -> metaflow.runner.subprocess_manager.SubprocessManager:
-        ...
-    def __aexit__(self, exc_type, exc_value, traceback):
-        ...
-    def run_command(self, command: typing.List[str], env: typing.Optional[typing.Dict[str, str]] = None, cwd: typing.Optional[str] = None, show_output: bool = False) -> int:
-        """
-        Run a command synchronously and return its process ID.
-        
-        Parameters
-        ----------
-        command : List[str]
-            The command to run in List form.
-        env : Optional[Dict[str, str]], default None
-            Environment variables to set for the subprocess; if not specified,
-            the current enviornment variables are used.
-        cwd : Optional[str], default None
-            The directory to run the subprocess in; if not specified, the current
-            directory is used.
-        show_output : bool, default False
-            Suppress the 'stdout' and 'stderr' to the console by default.
-            They can be accessed later by reading the files present in the
-            CommandManager object:
-                - command_obj.log_files["stdout"]
-                - command_obj.log_files["stderr"]
-        Returns
-        -------
-        int
-            The process ID of the subprocess.
-        """
-        ...
-    def async_run_command(self, command: typing.List[str], env: typing.Optional[typing.Dict[str, str]] = None, cwd: typing.Optional[str] = None) -> int:
-        """
-        Run a command asynchronously and return its process ID.
-        
-        Parameters
-        ----------
-        command : List[str]
-            The command to run in List form.
-        env : Optional[Dict[str, str]], default None
-            Environment variables to set for the subprocess; if not specified,
-            the current enviornment variables are used.
-        cwd : Optional[str], default None
-            The directory to run the subprocess in; if not specified, the current
-            directory is used.
-        
-        Returns
-        -------
-        int
-            The process ID of the subprocess.
-        """
-        ...
-    def get(self, pid: int) -> typing.Optional["CommandManager"]:
-        """
-        Get one of the CommandManager managed by this SubprocessManager.
-        
-        Parameters
-        ----------
-        pid : int
-            The process ID of the subprocess (returned by run_command or async_run_command).
-        
-        Returns
-        -------
-        Optional[CommandManager]
-            The CommandManager object for the given process ID, or None if not found.
-        """
-        ...
-    def cleanup(self):
-        """
-        Clean up log files for all running subprocesses.
-        """
-        ...
-    ...
+from ..client.core import Run as Run
+from .utils import handle_timeout as handle_timeout
+from .subprocess_manager import CommandManager as CommandManager
+from .subprocess_manager import SubprocessManager as SubprocessManager
 
 class ExecutingRun(object, metaclass=type):
     """
@@ -534,11 +49,11 @@ class ExecutingRun(object, metaclass=type):
             Run object corresponding to this run.
         """
         ...
-    def __enter__(self) -> ExecutingRun:
+    def __enter__(self) -> "ExecutingRun":
         ...
     def __exit__(self, exc_type, exc_value, traceback):
         ...
-    def wait(self, timeout: typing.Optional[float] = None, stream: typing.Optional[str] = None) -> ExecutingRun:
+    def wait(self, timeout: typing.Optional[float] = None, stream: typing.Optional[str] = None) -> "ExecutingRun":
         """
         Wait for this run to finish, optionally with a timeout
         and optionally streaming its output.
@@ -547,10 +62,11 @@ class ExecutingRun(object, metaclass=type):
         
         Parameters
         ----------
-        timeout : Optional[float], default None
-            The maximum time to wait for the run to finish.
-            If the timeout is reached, the run is terminated
-        stream : Optional[str], default None
+        timeout : float, optional, default None
+            The maximum time, in seconds, to wait for the run to finish.
+            If the timeout is reached, the run is terminated. If not specified, wait
+            forever.
+        stream : str, optional, default None
             If specified, the specified stream is printed to stdout. `stream` can
             be one of `stdout` or `stderr`.
         
@@ -626,7 +142,7 @@ class ExecutingRun(object, metaclass=type):
         ----------
         stream : str
             The stream to stream logs from. Can be one of `stdout` or `stderr`.
-        position : Optional[int], default None
+        position : int, optional, default None
             The position in the log file to start streaming from. If None, it starts
             from the beginning of the log file. This allows resuming streaming from
             a previously known position
@@ -665,13 +181,13 @@ class Runner(object, metaclass=type):
     show_output : bool, default True
         Show the 'stdout' and 'stderr' to the console by default,
         Only applicable for synchronous 'run' and 'resume' functions.
-    profile : Optional[str], default None
+    profile : str, optional, default None
         Metaflow profile to use to run this run. If not specified, the default
         profile is used (or the one already set using `METAFLOW_PROFILE`)
-    env : Optional[Dict], default None
+    env : Dict[str, str], optional, default None
         Additional environment variables to set for the Run. This overrides the
         environment set for this process.
-    cwd : Optional[str], default None
+    cwd : str, optional, default None
         The directory to run the subprocess in; if not specified, the current
         directory is used.
     file_read_timeout : int, default 3600
@@ -680,11 +196,11 @@ class Runner(object, metaclass=type):
         Additional arguments that you would pass to `python myflow.py` before
         the `run` command.
     """
-    def __init__(self, flow_file: str, show_output: bool = True, profile: typing.Optional[str] = None, env: typing.Optional[typing.Dict] = None, cwd: typing.Optional[str] = None, file_read_timeout: int = 3600, **kwargs):
+    def __init__(self, flow_file: str, show_output: bool = True, profile: typing.Optional[str] = None, env: typing.Optional[typing.Dict[str, str]] = None, cwd: typing.Optional[str] = None, file_read_timeout: int = 3600, **kwargs):
         ...
-    def __enter__(self) -> Runner:
+    def __enter__(self) -> "Runner":
         ...
-    def __aenter__(self) -> Runner:
+    def __aenter__(self) -> "Runner":
         ...
     def _Runner__get_executing_run(self, tfp_runner_attribute, command_obj):
         ...

metaflow-stubs/runner/nbdeploy.pyi

@@ -1,65 +1,16 @@
-##################################################################################
-#                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.27.1+obcheckpoint(0.1.2);ob(v1)                               #
-# Generated on 2024-11-13T19:05:29.367864                                        #
-##################################################################################
+######################################################################################################
+#                                 Auto-generated Metaflow stub file                                  #
+# MF version: 2.12.30.2+obcheckpoint(0.1.4);ob(v1)                                                   #
+# Generated on 2024-11-21T22:12:20.812268                                                            #
+######################################################################################################
 
 from __future__ import annotations
 
 import typing
 
-class Deployer(object, metaclass=type):
-    """
-    Use the `Deployer` class to configure and access one of the production
-    orchestrators supported by Metaflow.
-    
-    Parameters
-    ----------
-    flow_file : str
-        Path to the flow file to deploy.
-    show_output : bool, default True
-        Show the 'stdout' and 'stderr' to the console by default.
-    profile : Optional[str], default None
-        Metaflow profile to use for the deployment. If not specified, the default
-        profile is used.
-    env : Optional[Dict[str, str]], default None
-        Additional environment variables to set for the deployment.
-    cwd : Optional[str], default None
-        The directory to run the subprocess in; if not specified, the current
-        directory is used.
-    file_read_timeout : int, default 3600
-        The timeout until which we try to read the deployer attribute file.
-    **kwargs : Any
-        Additional arguments that you would pass to `python myflow.py` before
-        the deployment command.
-    """
-    def __init__(self, flow_file: str, show_output: bool = True, profile: typing.Optional[str] = None, env: typing.Optional[typing.Dict] = None, cwd: typing.Optional[str] = None, file_read_timeout: int = 3600, **kwargs):
-        ...
-    def _Deployer__make_function(self, deployer_class):
-        """
-        Create a function for the given deployer class.
-        
-        Parameters
-        ----------
-        deployer_class : Type[DeployerImpl]
-            Deployer implementation class.
-        
-        Returns
-        -------
-        Callable
-            Function that initializes and returns an instance of the deployer class.
-        """
-        ...
-    ...
-
-def get_current_cell(ipython):
-    ...
-
-def format_flowfile(cell):
-    """
-    Formats the given cell content to create a valid Python script that can be executed as a Metaflow flow.
-    """
-    ...
+from .deployer import Deployer as Deployer
+from .utils import get_current_cell as get_current_cell
+from .utils import format_flowfile as format_flowfile
 
 class NBDeployerInitializationError(Exception, metaclass=type):
     """
@@ -92,13 +43,13 @@ class NBDeployer(object, metaclass=type):
         Flow defined in the same cell
     show_output : bool, default True
         Show the 'stdout' and 'stderr' to the console by default,
-    profile : Optional[str], default None
+    profile : str, optional, default None
         Metaflow profile to use to deploy this run. If not specified, the default
         profile is used (or the one already set using `METAFLOW_PROFILE`)
-    env : Optional[Dict[str, str]], default None
+    env : Dict[str, str], optional, default None
         Additional environment variables to set. This overrides the
         environment set for this process.
-    base_dir : Optional[str], default None
+    base_dir : str, optional, default None
         The directory to run the subprocess in; if not specified, the current
         working directory is used.
     **kwargs : Any
@@ -107,6 +58,11 @@ class NBDeployer(object, metaclass=type):
     """
     def __init__(self, flow, show_output: bool = True, profile: typing.Optional[str] = None, env: typing.Optional[typing.Dict] = None, base_dir: typing.Optional[str] = None, file_read_timeout: int = 3600, **kwargs):
         ...
+    def __getattr__(self, name):
+        """
+        Forward all attribute access to the underlying `Deployer` instance.
+        """
+        ...
     def cleanup(self):
         """
         Delete any temporary files created during execution.