looper 1.5.0__tar.gz → 1.6.0a1__tar.gz

{looper-1.5.0/looper.egg-info → looper-1.6.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: looper
-Version: 1.5.0
+Version: 1.6.0a1
 Summary: A pipeline submission engine that parses sample inputs and submits pipelines for each sample.
 Home-page: https://github.com/pepkit/looper
 Author: Nathan Sheffield, Vince Reuter, Michal Stolarczyk, Johanna Klughammer, Andre Rendeiro
@@ -15,6 +15,19 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: colorama>=0.3.9
+Requires-Dist: divvy>=0.5.0
+Requires-Dist: eido>=0.2.1
+Requires-Dist: jinja2
+Requires-Dist: logmuse>=0.2.0
+Requires-Dist: pandas>=2.0.2
+Requires-Dist: pephubclient>=0.1.2
+Requires-Dist: peppy>=0.40.0.a4
+Requires-Dist: pipestat>=v0.6.0a9
+Requires-Dist: pyyaml>=3.12
+Requires-Dist: rich>=9.10.0
+Requires-Dist: ubiquerg>=0.5.2
+Requires-Dist: yacman>=0.9.2
 
 # <img src="docs/img/looper_logo.svg" alt="looper logo" height="70">
 

looper-1.6.0a1/looper/__init__.py

@@ -0,0 +1,44 @@
+"""Project configuration, particularly for logging.
+
+Project-scope constants may reside here, but more importantly, some setup here
+will provide a logging infrastructure for all of the project's modules.
+Individual modules and classes may provide separate configuration on a more
+local level, but this will at least provide a foundation.
+
+"""
+
+import logmuse
+
+logmuse.init_logger("looper")
+
+from .divvy import ComputingConfiguration, select_divvy_config
+from .divvy import DEFAULT_COMPUTE_RESOURCES_NAME
+from .divvy import NEW_COMPUTE_KEY as COMPUTE_KEY
+
+from ._version import __version__
+from .conductor import (
+    SubmissionConductor,
+    write_submission_yaml,
+)
+from .plugins import (
+    write_sample_yaml,
+    write_sample_yaml_cwl,
+    write_sample_yaml_prj,
+    write_custom_template,
+)
+from .const import *
+from .pipeline_interface import PipelineInterface
+from .project import Project
+
+# Not used here, but make this the main import interface between peppy and
+# looper, so that other modules within this package need not worry about
+# the locations of some of the peppy declarations. Effectively, concentrate
+# the connection between peppy and looper here, to the extent possible.
+
+__all__ = [
+    "Project",
+    "PipelineInterface",
+    "SubmissionConductor",
+    "ComputingConfiguration",
+    "select_divvy_config",
+]

{looper-1.5.0 → looper-1.6.0a1}/looper/__main__.py

@@ -1,7 +1,7 @@
 import sys
 
-from .looper import main
-from .divvy import main as divvy_main
+from .cli_looper import main
+from .cli_divvy import main as divvy_main
 
 if __name__ == "__main__":
     try:

looper-1.6.0a1/looper/_version.py

@@ -0,0 +1 @@
+__version__ = "1.6.0a1"

looper-1.6.0a1/looper/cli_divvy.py

@@ -0,0 +1,182 @@
+import logmuse
+import os
+import sys
+import yaml
+from yaml import SafeLoader
+from ubiquerg import is_writable, VersionInHelpParser
+from .const import (
+    DEFAULT_COMPUTE_RESOURCES_NAME,
+    DEFAULT_CONFIG_FILEPATH,
+)
+from .divvy import select_divvy_config, ComputingConfiguration, divvy_init
+
+
+def build_argparser():
+    """
+    Builds argument parser.
+
+    :return argparse.ArgumentParser
+    """
+
+    banner = (
+        "%(prog)s - write compute job scripts that can be submitted to "
+        "any computing resource"
+    )
+    additional_description = "\nhttps://divvy.databio.org"
+
+    parser = VersionInHelpParser(
+        prog="divvy",
+        description=banner,
+        epilog=additional_description,
+        # version=__version__,
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    def add_subparser(cmd, description):
+        return subparsers.add_parser(cmd, description=description, help=description)
+
+    subparser_messages = {
+        "init": "Initialize a new divvy config file",
+        "list": "List available compute packages",
+        "write": "Write a job script",
+        "submit": "Write and then submit a job script",
+        "inspect": "Inspect compute package",
+    }
+
+    sps = {}
+    for cmd, desc in subparser_messages.items():
+        sps[cmd] = add_subparser(cmd, desc)
+        # sps[cmd].add_argument(
+        #     "config", nargs="?", default=None,
+        #     help="Divvy configuration file.")
+
+    for sp in [sps["list"], sps["write"], sps["submit"], sps["inspect"]]:
+        sp.add_argument(
+            "config", nargs="?", default=None, help="Divvy configuration file."
+        )
+
+    sps["init"].add_argument("config", default=None, help="Divvy configuration file.")
+
+    for sp in [sps["inspect"]]:
+        sp.add_argument(
+            "-p",
+            "--package",
+            default=DEFAULT_COMPUTE_RESOURCES_NAME,
+            help="Select from available compute packages",
+        )
+
+    for sp in [sps["write"], sps["submit"]]:
+        sp.add_argument(
+            "-s",
+            "--settings",
+            help="YAML file with job settings to populate the template",
+        )
+
+        sp.add_argument(
+            "-p",
+            "--package",
+            default=DEFAULT_COMPUTE_RESOURCES_NAME,
+            help="Select from available compute packages",
+        )
+
+        sp.add_argument(
+            "-c",
+            "--compute",
+            nargs="+",
+            default=None,
+            help="Extra key=value variable pairs",
+        )
+
+        # sp.add_argument(
+        #         "-t", "--template",
+        #         help="Provide a template file (not yet implemented).")
+
+        sp.add_argument(
+            "-o", "--outfile", required=False, default=None, help="Output filepath"
+        )
+
+    return parser
+
+
+def main():
+    """Primary workflow for divvy CLI"""
+
+    parser = logmuse.add_logging_options(build_argparser())
+    # args, remaining_args = parser.parse_known_args()
+    args = parser.parse_args()
+
+    logger_kwargs = {"level": args.verbosity, "devmode": args.logdev}
+    logmuse.init_logger("yacman", **logger_kwargs)
+    global _LOGGER
+    _LOGGER = logmuse.logger_via_cli(args)
+
+    if not args.command:
+        parser.print_help()
+        _LOGGER.error("No command given")
+        sys.exit(1)
+
+    if args.command == "init":
+        divcfg = args.config
+        _LOGGER.debug("Initializing divvy configuration")
+        is_writable(os.path.dirname(divcfg), check_exist=False)
+        divvy_init(divcfg, DEFAULT_CONFIG_FILEPATH)
+        sys.exit(0)
+
+    _LOGGER.debug("Divvy config: {}".format(args.config))
+    divcfg = select_divvy_config(args.config)
+    _LOGGER.info("Using divvy config: {}".format(divcfg))
+    dcc = ComputingConfiguration(filepath=divcfg)
+
+    if args.command == "list":
+        # Output header via logger and content via print so the user can
+        # redirect the list from stdout if desired without the header as clutter
+        _LOGGER.info("Available compute packages:\n")
+        print("{}".format("\n".join(dcc.list_compute_packages())))
+        sys.exit(1)
+
+    if args.command == "inspect":
+        # Output contents of selected compute package
+        _LOGGER.info("Your compute package template for: " + args.package + "\n")
+        found = False
+        for pkg_name, pkg in dcc.compute_packages.items():
+            if pkg_name == args.package:
+                found = True
+                with open(pkg.submission_template, "r") as f:
+                    print(f.read())
+                _LOGGER.info("Submission command is: " + pkg.submission_command + "\n")
+                if pkg_name == "docker":
+                    print("Docker args are: " + pkg.docker_args)
+
+        if not found:
+            _LOGGER.info("Package not found. Use 'divvy list' to see list of packages.")
+        sys.exit(1)
+
+    # Any non-divvy arguments will be passed along as key-value pairs
+    # that can be used to populate the template.
+    # keys = [str.replace(x, "--", "") for x in remaining_args[::2]]
+    # cli_vars = dict(zip(keys, remaining_args[1::2]))
+    if args.compute:
+        cli_vars = {y[0]: y[1] for y in [x.split("=") for x in args.compute]}
+    else:
+        cli_vars = {}
+
+    if args.command == "write" or args.command == "submit":
+        try:
+            dcc.activate_package(args.package)
+        except AttributeError:
+            parser.print_help(sys.stderr)
+            sys.exit(1)
+
+        if args.settings:
+            _LOGGER.info("Loading settings file: %s", args.settings)
+            with open(args.settings, "r") as f:
+                vars_groups = [cli_vars, yaml.load(f, SafeLoader)]
+        else:
+            vars_groups = [cli_vars]
+
+        _LOGGER.debug(vars_groups)
+        if args.command == "write":
+            dcc.write_script(args.outfile, vars_groups)
+        elif args.command == "submit":
+            dcc.submit(args.outfile, vars_groups)