Metadata-Version: 2.1
Name: OarLauncher
Version: 0.2.24
Summary: Description
Home-page: https://github.com/GaetanDesrues/OarLauncher
Author: Gaetan Desrues
Author-email: gaetan.desrues@inria.fr
License: UNKNOWN
Description: ### Simply start oar job array on nef cluster
        
        **NB**: To simply start a stand-alone job, use [`treefiles.start_oar`](https://github.com/GaetanDesrues/TreeFiles/blob/master/treefiles/oar.py#L64-L178).
        
        
        #### Install
        ```bash
        pip install --upgrade OarLauncher
        ```
        
        
        #### Usage
        ```python
        from collections import defaultdict
        import treefiles as tf
        from OarLauncher import ArrayJob
        
        
        # Choose a directory where script and logs are dumped
        out_dir = tf.Tree.new(__file__, "generated").dump(clean=True)
        
        # Create the parameters array
        nb_jobs, data = 10, defaultdict(list)
        for i in range(nb_jobs):
            data["simu_dir"].append(f"d_{i}")
            data["infos"].append(f"this is job {i}")
        
        # Path of the script that will be called by each job of the array
        # Each line of data will be sent to this script as json command line argument
        job_script = tf.curDirs(__file__, "job.py")
        
        # Create the job array
        jobs = ArrayJob(out_dir, data, job_script)
        # Setup jobs conf
        jobs.build_oar_command(
            queue=tf.Queue.BESTEFFORT,
            to_file=True,  # whereas `shell_out` is dumped to file or returned via command line
            wall_time=tf.walltime(minutes=2),
            prgm=tf.Program.OARCTL,  # `OARCTL` is blocking (main process is running until all jobs end), `OARSUB` is not
        )
        # Write scripts
        jobs.dump(
            # python_path=[...],  # you can give a list of python paths that will be added to PYTHONPATH
            # MY_ENV=...,  # you can also specify PATH envs by passing them as kwargs
        )
        # Start the job array
        shell_out = jobs.run()  # blocking operation if prgm=tf.Program.OARCTL
        print(shell_out)
        ```
        
        ## `tf.start_oar`
        
        ```python
        def start_oar(
            runme_str,
            logs_dir: Union[tf.Tree, str] = None,
            array_fname: str = None,
            wall_time: str = walltime(minutes=1),
            host: int = 1,
            core: int = 1,
            job_name: str = None,
            queue: str = Queue.DEFAULT,
            cmd_fname: str = None,
            runme_args: List[str] = None,
            do_run: bool = True,
            with_json: bool = False,
            notify: List = None,
            prgm: str = Program.OARSUB,
            stdout: str = None,
            stderr: str = None,
        ) -> Union[str, List[str]]:
            """
            Builds an oar command.
            Usage example:
            .. code::
                    cdir = tf.Tree.new(__file__)
                    sdir = cdir.dir("OarOut").dump(clean=True)
                    res = start_oar(
                        runme_str=cdir.path("runme.sh"),
                        logs_dir=sdir,
                        walltime=time(minute=10),
                        queue="besteffort",
                        core=2,
                        cmd_fname=sdir.path("cmd.sh"),
                        do_run=True,
                    )
            :param runme_str: path to the runme script or command line
            :param logs_dir: directory for std out/err
            :param array_fname: path to the arguments file (array file)
            :param wall_time: wall time of the job
            :param host: numbre of nodes
            :param core: number of cores
            :param job_name: job name
            :param queue: job queue ['default', 'besteffort']
            :param cmd_fname: path to a file to save the oar command
            :param runme_args: list of command line arguments given to the runme script
            :param do_run: whether to execute the command or not
            :param with_json: add the -J option in oarsub command
            :param notify: notify options [List], you may use the class NotifyOar to build this option
            :param prgm: `oarsub` or `oarctl sub`
            :param stdout: path for stdout
            :param stderr: path for stderr, defaults to stdout if None
            :return: The output of the oar command if `do_run` is True else the oar command
            """
        ```
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
