looper 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

looper/_version.py

@@ -1 +1,2 @@
-__version__ = "1.8.0"
+__version__ = "1.9.0"
+# You must change the version in parser = pydantic2_argparse.ArgumentParser in cli_pydantic.py!!!

looper/cli_pydantic.py

@@ -17,19 +17,17 @@ It is well possible that this script will be removed again.
 # with types.
 from __future__ import annotations
 
-import os
 import sys
 
 import logmuse
-import pydantic2_argparse
+import pydantic_argparse
 import yaml
 from eido import inspect_project
 from pephubclient import PEPHubClient
-from pydantic2_argparse.argparse.parser import ArgumentParser
+from pydantic_argparse.argparse.parser import ArgumentParser
 
 from divvy import select_divvy_config
 
-from .const import PipelineLevel
 from . import __version__
 
 from .command_models.arguments import ArgumentEnum
@@ -151,8 +149,12 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
                 looper_config_dict = read_looper_dotfile()
                 _LOGGER.info(f"Using looper config ({looper_cfg_path}).")
 
+            cli_modifiers_dict = None
             for looper_config_key, looper_config_item in looper_config_dict.items():
-                setattr(subcommand_args, looper_config_key, looper_config_item)
+                if looper_config_key == CLI_KEY:
+                    cli_modifiers_dict = looper_config_item
+                else:
+                    setattr(subcommand_args, looper_config_key, looper_config_item)
 
         except OSError:
             parser.print_help(sys.stderr)
@@ -168,7 +170,11 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
         )
 
     subcommand_args = enrich_args_via_cfg(
-        subcommand_name, subcommand_args, parser, test_args=test_args
+        subcommand_name,
+        subcommand_args,
+        parser,
+        test_args=test_args,
+        cli_modifiers=cli_modifiers_dict,
     )
 
     # If project pipeline interface defined in the cli, change name to: "pipeline_interface"
@@ -246,11 +252,15 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
         # Check at the beginning if user wants to use pipestat and pipestat is configurable
         is_pipestat_configured = (
             prj._check_if_pipestat_configured(pipeline_type=PipelineLevel.PROJECT.value)
-            if getattr(args, "project", None)
+            if getattr(subcommand_args, "project", None)
             else prj._check_if_pipestat_configured()
         )
 
         if subcommand_name in ["run", "rerun"]:
+            if getattr(subcommand_args, "project", None):
+                _LOGGER.warning(
+                    "Project flag set but 'run' command was used. Please use 'runp' to run at project-level."
+                )
             rerun = subcommand_name == "rerun"
             run = Runner(prj)
             try:
@@ -321,11 +331,12 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
 
 
 def main(test_args=None) -> None:
-    parser = pydantic2_argparse.ArgumentParser(
+    parser = pydantic_argparse.ArgumentParser(
         model=TopLevelParser,
         prog="looper",
-        description="Looper Pydantic Argument Parser",
+        description="Looper: A job submitter for Portable Encapsulated Projects",
         add_help=True,
+        version="1.9.0",
     )
 
     parser = add_short_arguments(parser, ArgumentEnum)

looper/command_models/commands.py

@@ -9,7 +9,7 @@ import pydantic.v1 as pydantic
 
 from ..const import MESSAGE_BY_SUBCOMMAND
 from .arguments import Argument, ArgumentEnum
-from pydantic2_argparse import ArgumentParser
+from pydantic_argparse import ArgumentParser
 
 
 @dataclass

looper/conductor.py

@@ -4,10 +4,12 @@ import importlib
 import logging
 import os
 import subprocess
+import signal
+import psutil
+import sys
 import time
 import yaml
 from math import ceil
-from copy import copy, deepcopy
 from json import loads
 from subprocess import check_output
 from typing import *
@@ -19,14 +21,18 @@ from jinja2.exceptions import UndefinedError
 from peppy.const import CONFIG_KEY, SAMPLE_NAME_ATTR, SAMPLE_YAML_EXT
 from peppy.exceptions import RemoteYAMLError
 from pipestat import PipestatError
-from ubiquerg import expandpath, is_command_callable
+from ubiquerg import expandpath
 from yaml import dump
 from yacman import FutureYAMLConfigManager as YAMLConfigManager
 
 from .const import *
-from .exceptions import JobSubmissionException, SampleFailedException
+from .exceptions import JobSubmissionException
 from .processed_project import populate_sample_paths
-from .utils import fetch_sample_flags, jinja_render_template_strictly
+from .utils import (
+    fetch_sample_flags,
+    jinja_render_template_strictly,
+    expand_nested_var_templates,
+)
 from .const import PipelineLevel
 
 
@@ -189,6 +195,7 @@ class SubmissionConductor(object):
             the project level, rather that on the sample level)
         """
         super(SubmissionConductor, self).__init__()
+
         self.collate = collate
         self.section_key = PROJECT_PL_KEY if self.collate else SAMPLE_PL_KEY
         self.pl_iface = pipeline_interface
@@ -210,6 +217,7 @@ class SubmissionConductor(object):
         self._curr_size = 0
         self._failed_sample_names = []
         self._curr_skip_pool = []
+        self.process_id = None  # this is used for currently submitted subprocess
 
         if self.extra_pipe_args:
             _LOGGER.debug(
@@ -392,6 +400,10 @@ class SubmissionConductor(object):
             not for dry run)
         """
         submitted = False
+
+        # Override signal handler so that Ctrl+C can be used to gracefully terminate child process
+        signal.signal(signal.SIGINT, self._signal_int_handler)
+
         if not self._pool:
             _LOGGER.debug("No submission (no pooled samples): %s", self.pl_name)
             # submitted = False
@@ -420,9 +432,10 @@ class SubmissionConductor(object):
                 submission_command = "{} {}".format(sub_cmd, script)
                 # Capture submission command return value so that we can
                 # intercept and report basic submission failures; #167
-                try:
-                    subprocess.check_call(submission_command, shell=True)
-                except subprocess.CalledProcessError:
+                process = subprocess.Popen(submission_command, shell=True)
+                self.process_id = process.pid
+                process.wait()
+                if process.returncode != 0:
                     fails = (
                         "" if self.collate else [s.sample_name for s in self._samples]
                     )
@@ -489,6 +502,87 @@ class SubmissionConductor(object):
             # name concordant with 1-based, not 0-based indexing.
             return "lump{}".format(self._num_total_job_submissions + 1)
 
+    def _signal_int_handler(self, signal, frame):
+        """
+        For catching interrupt (Ctrl +C) signals. Fails gracefully.
+        """
+        signal_type = "SIGINT"
+        self._generic_signal_handler(signal_type)
+
+    def _generic_signal_handler(self, signal_type):
+        """
+        Function for handling both SIGTERM and SIGINT
+        """
+        message = "Received " + signal_type + ". Failing gracefully..."
+        _LOGGER.warning(msg=message)
+
+        self._terminate_current_subprocess()
+
+        sys.exit(1)
+
+    def _terminate_current_subprocess(self):
+        """This terminates the current sub process associated with self.process_id"""
+
+        def pskill(proc_pid, sig=signal.SIGINT):
+            parent_process = psutil.Process(proc_pid)
+            for child_proc in parent_process.children(recursive=True):
+                child_proc.send_signal(sig)
+            parent_process.send_signal(sig)
+
+        if self.process_id is None:
+            return
+
+        # Gently wait for the subprocess before attempting to kill it
+        sys.stdout.flush()
+        still_running = self._attend_process(psutil.Process(self.process_id), 0)
+        sleeptime = 0.25
+        time_waiting = 0
+
+        while still_running and time_waiting < 3:
+            try:
+                if time_waiting > 2:
+                    pskill(self.process_id, signal.SIGKILL)
+                elif time_waiting > 1:
+                    pskill(self.process_id, signal.SIGTERM)
+                else:
+                    pskill(self.process_id, signal.SIGINT)
+
+            except OSError:
+                # This would happen if the child process ended between the check
+                # and the next kill step
+                still_running = False
+                time_waiting = time_waiting + sleeptime
+
+            # Now see if it's still running
+            time_waiting = time_waiting + sleeptime
+            if not self._attend_process(psutil.Process(self.process_id), sleeptime):
+                still_running = False
+
+        if still_running:
+            _LOGGER.warning(f"Unable to halt child process: {self.process_id}")
+        else:
+            if time_waiting > 0:
+                note = f"terminated after {time_waiting} sec"
+            else:
+                note = "was already terminated"
+            _LOGGER.warning(msg=f"Child process {self.process_id} {note}.")
+
+    def _attend_process(self, proc, sleeptime):
+        """
+        Waits on a process for a given time to see if it finishes, returns True
+        if it's still running after the given time or False as soon as it
+        returns.
+
+        :param psutil.Process proc: Process object opened by psutil.Popen()
+        :param float sleeptime: Time to wait
+        :return bool: True if process is still running; otherwise false
+        """
+        try:
+            proc.wait(timeout=int(sleeptime))
+        except psutil.TimeoutExpired:
+            return True
+        return False
+
     def _jobname(self, pool):
         """Create the name for a job submission."""
         return "{}_{}".format(self.pl_iface.pipeline_name, self._sample_lump_name(pool))
@@ -563,6 +657,7 @@ class SubmissionConductor(object):
                 "results_file": psm.file,
                 "record_identifier": psm.record_identifier,
                 "config_file": psm.config_path,
+                "output_schema": psm.cfg["_schema_path"],
             }
             filtered_namespace = {k: v for k, v in full_namespace.items() if v}
             return YAMLConfigManager(filtered_namespace)
@@ -626,8 +721,10 @@ class SubmissionConductor(object):
             _LOGGER.debug(f"namespace pipelines: { pl_iface }")
 
             namespaces["pipeline"]["var_templates"] = pl_iface[VAR_TEMPL_KEY] or {}
-            for k, v in namespaces["pipeline"]["var_templates"].items():
-                namespaces["pipeline"]["var_templates"][k] = expandpath(v)
+
+            namespaces["pipeline"]["var_templates"] = expand_nested_var_templates(
+                namespaces["pipeline"]["var_templates"], namespaces
+            )
 
             # pre_submit hook namespace updates
             namespaces = _exec_pre_submit(pl_iface, namespaces)

looper/const.py

@@ -93,6 +93,7 @@ __all__ = [
     "DEBUG_EIDO_VALIDATION",
     "LOOPER_GENERIC_OUTPUT_SCHEMA",
     "LOOPER_GENERIC_COUNT_LINES",
+    "PipelineLevel",
 ]
 
 FLAGS = ["completed", "running", "failed", "waiting", "partial"]

looper/divvy.py

@@ -1,18 +1,13 @@
 """ Computing configuration representation """
 
 import logging
-import logmuse
 import os
-import sys
 import shutil
-import yaml
 
 
 from shutil import copytree
 from yacman import FutureYAMLConfigManager as YAMLConfigManager
 from yacman import write_lock, FILEPATH_KEY, load_yaml, select_config
-from yaml import SafeLoader
-from ubiquerg import is_writable, VersionInHelpParser
 
 
 from .const import (
@@ -24,7 +19,6 @@ from .const import (
 )
 from .utils import write_submit_script
 
-# from . import __version__
 
 _LOGGER = logging.getLogger(__name__)
 

looper/looper.py

@@ -33,14 +33,12 @@ from rich.color import Color
 from rich.console import Console
 from rich.table import Table
 from ubiquerg.cli_tools import query_yes_no
-from ubiquerg.collection import uniqify
 
 
 from .conductor import SubmissionConductor
 
 from .exceptions import *
 from .const import *
-from .pipeline_interface import PipelineInterface
 from .project import Project
 from .utils import (
     desired_samples_range_skipped,
@@ -94,7 +92,7 @@ class Checker(Executor):
         psms = {}
         if getattr(args, "project", None):
 
-            for piface in self.prj.pipeline_interfaces:
+            for piface in self.prj.project_pipeline_interfaces:
                 if piface.psm.pipeline_type == PipelineLevel.PROJECT.value:
                     psms[piface.psm.pipeline_name] = piface.psm
                     s = piface.psm.get_status() or "unknown"
@@ -565,7 +563,7 @@ class Reporter(Executor):
 
         if project_level:
 
-            for piface in self.prj.pipeline_interfaces:
+            for piface in self.prj.project_pipeline_interfaces:
                 if piface.psm.pipeline_type == PipelineLevel.PROJECT.value:
                     psms[piface.psm.pipeline_name] = piface.psm
                     report_directory = piface.psm.summarize(
@@ -598,7 +596,7 @@ class Linker(Executor):
         psms = {}
 
         if project_level:
-            for piface in self.prj.pipeline_interfaces:
+            for piface in self.prj.project_pipeline_interfaces:
                 if piface.psm.pipeline_type == PipelineLevel.PROJECT.value:
                     psms[piface.psm.pipeline_name] = piface.psm
                     linked_results_path = piface.psm.link(link_dir=link_dir)
@@ -623,7 +621,7 @@ class Tabulator(Executor):
         results = []
         psms = {}
         if project_level:
-            for piface in self.prj.pipeline_interfaces:
+            for piface in self.prj.project_pipeline_interfaces:
                 if piface.psm.pipeline_type == PipelineLevel.PROJECT.value:
                     psms[piface.psm.pipeline_name] = piface.psm
                     results = piface.psm.table()

looper/pipeline_interface.py

@@ -17,7 +17,7 @@ from .exceptions import (
     InvalidResourceSpecificationException,
     PipelineInterfaceConfigError,
 )
-from .utils import jinja_render_template_strictly
+from .utils import render_nested_var_templates
 
 __author__ = "Michal Stolarczyk"
 __email__ = "michal@virginia.edu"
@@ -89,8 +89,7 @@ class PipelineInterface(YAMLConfigManager):
             var_templates = {}
             if curr_data:
                 var_templates.update(curr_data)
-                for k, v in var_templates.items():
-                    var_templates[k] = jinja_render_template_strictly(v, namespaces)
+                var_templates = render_nested_var_templates(var_templates, namespaces)
             return var_templates
 
     def get_pipeline_schemas(self, schema_key=INPUT_SCHEMA_KEY):

looper/project.py

@@ -10,18 +10,14 @@ try:
 except ImportError:
     # cached_property was introduced in python 3.8
     cached_property = property
-from logging import getLogger
 
 from .divvy import ComputingConfiguration
 from eido import PathAttrNotFoundError, read_schema
 from jsonschema import ValidationError
 from pandas.core.common import flatten
-from peppy import CONFIG_KEY, OUTDIR_KEY
-from peppy import Project as peppyProject
 from peppy.utils import make_abs_via_cfg
-from pipestat import PipestatError, PipestatManager
-from ubiquerg import expandpath, is_command_callable
-from yacman import YAMLConfigManager
+from pipestat import PipestatManager
+
 from .conductor import write_pipestat_config
 
 from .exceptions import *
@@ -374,65 +370,6 @@ class Project(peppyProject):
         except KeyError:
             return None
 
-    def build_submission_bundles(self, protocol, priority=True):
-        """
-        Create pipelines to submit for each sample of a particular protocol.
-
-        With the argument (flag) to the priority parameter, there's control
-        over whether to submit pipeline(s) from only one of the project's
-        known pipeline locations with a match for the protocol, or whether to
-        submit pipelines created from all locations with a match for the
-        protocol.
-
-        :param str protocol: name of the protocol/library for which to
-            create pipeline(s)
-        :param bool priority: to only submit pipeline(s) from the first of the
-            pipelines location(s) (indicated in the project config file) that
-            has a match for the given protocol; optional, default True
-        :return Iterable[(PipelineInterface, type, str, str)]:
-        :raises AssertionError: if there's a failure in the attempt to
-            partition an interface's pipeline scripts into disjoint subsets of
-            those already mapped and those not yet mapped
-        """
-
-        if not priority:
-            raise NotImplementedError(
-                "Currently, only prioritized protocol mapping is supported "
-                "(i.e., pipeline interfaces collection is a prioritized list, "
-                "so only the first interface with a protocol match is used.)"
-            )
-
-        # Pull out the collection of interfaces (potentially one from each of
-        # the locations indicated in the project configuration file) as a
-        # sort of pool of information about possible ways in which to submit
-        # pipeline(s) for sample(s) of the indicated protocol.
-        pifaces = self.interfaces.get_pipeline_interface(protocol)
-        if not pifaces:
-            raise PipelineInterfaceConfigError(
-                "No interfaces for protocol: {}".format(protocol)
-            )
-
-        # coonvert to a list, in the future we might allow to match multiple
-        pifaces = pifaces if isinstance(pifaces, str) else [pifaces]
-
-        job_submission_bundles = []
-        new_jobs = []
-
-        _LOGGER.debug("Building pipelines matched by protocol: {}".format(protocol))
-
-        for pipe_iface in pifaces:
-            # Determine how to reference the pipeline and where it is.
-            path = pipe_iface["path"]
-            if not (os.path.exists(path) or is_command_callable(path)):
-                _LOGGER.warning("Missing pipeline script: {}".format(path))
-                continue
-
-            # Add this bundle to the collection of ones relevant for the
-            # current PipelineInterface.
-            new_jobs.append(pipe_iface)
-            job_submission_bundles.append(new_jobs)
-        return list(itertools.chain(*job_submission_bundles))
-
     @staticmethod
     def get_schemas(pifaces, schema_key=INPUT_SCHEMA_KEY):
         """

looper/utils.py

@@ -1,12 +1,11 @@
 """ Helpers without an obvious logical home. """
 
 import argparse
-from collections import defaultdict, namedtuple
+from collections import defaultdict
 import glob
 import itertools
 from logging import getLogger
 import os
-import sys
 from typing import *
 import re
 
@@ -14,13 +13,14 @@ import jinja2
 import yaml
 from peppy import Project as peppyProject
 from peppy.const import *
-from ubiquerg import convert_value, expandpath, parse_registry_path
+from ubiquerg import convert_value, expandpath, parse_registry_path, deep_update
 from pephubclient.constants import RegistryPath
 from pydantic import ValidationError
+from yacman import load_yaml
 
 from .const import *
 from .command_models.commands import SUPPORTED_COMMANDS
-from .exceptions import MisconfigurationException, RegistryPathException
+from .exceptions import MisconfigurationException
 
 _LOGGER = getLogger(__name__)
 
@@ -253,7 +253,13 @@ def read_yaml_file(filepath):
     return data
 
 
-def enrich_args_via_cfg(subcommand_name, parser_args, aux_parser, test_args=None):
+def enrich_args_via_cfg(
+    subcommand_name,
+    parser_args,
+    aux_parser,
+    test_args=None,
+    cli_modifiers=None,
+):
     """
     Read in a looper dotfile and set arguments.
 
@@ -270,6 +276,33 @@ def enrich_args_via_cfg(subcommand_name, parser_args, aux_parser, test_args=None
         if os.path.exists(parser_args.config_file)
         else dict()
     )
+
+    # If user provided project-level modifiers in the looper config, they are prioritized
+    if cfg_args_all:
+        for key, value in cfg_args_all.items():
+            if getattr(parser_args, key, None):
+                new_value = getattr(parser_args, key)
+                cfg_args_all[key] = new_value
+    else:
+        cfg_args_all = {}
+
+    looper_config_cli_modifiers = None
+    if cli_modifiers:
+        if str(subcommand_name) in cli_modifiers:
+            looper_config_cli_modifiers = cli_modifiers[subcommand_name]
+            looper_config_cli_modifiers = (
+                {k.replace("-", "_"): v for k, v in looper_config_cli_modifiers.items()}
+                if looper_config_cli_modifiers
+                else None
+            )
+
+    if looper_config_cli_modifiers:
+        _LOGGER.warning(
+            "CLI modifiers were provided in Looper Config and in PEP Project Config. Merging..."
+        )
+        deep_update(cfg_args_all, looper_config_cli_modifiers)
+        _LOGGER.debug(msg=f"Merged CLI modifiers: {cfg_args_all}")
+
     result = argparse.Namespace()
     if test_args:
         cli_args, _ = aux_parser.parse_known_args(args=test_args)
@@ -503,6 +536,33 @@ def initiate_looper_config(
     return True
 
 
+def determine_pipeline_type(piface_path: str, looper_config_path: str):
+    """
+    Read pipeline interface from disk and determine if pipeline type is sample or project-level
+
+
+    :param str piface_path: path to pipeline_interface
+    :param str looper_config_path: path to looper config file
+    :return Tuple[Union[str,None],Union[str,None]] : (pipeline type, resolved path) or (None, None)
+    """
+
+    if piface_path is None:
+        return None, None
+    piface_path = expandpath(piface_path)
+    if not os.path.isabs(piface_path):
+        piface_path = os.path.realpath(
+            os.path.join(os.path.dirname(looper_config_path), piface_path)
+        )
+    try:
+        piface_dict = load_yaml(piface_path)
+    except FileNotFoundError:
+        return None, None
+
+    pipeline_type = piface_dict.get("pipeline_type", None)
+
+    return pipeline_type, piface_path
+
+
 def read_looper_config_file(looper_config_path: str) -> dict:
     """
     Read Looper config file which includes:
@@ -543,12 +603,46 @@ def read_looper_config_file(looper_config_path: str) -> dict:
     if PIPESTAT_KEY in dp_data:
         return_dict[PIPESTAT_KEY] = dp_data[PIPESTAT_KEY]
 
+    if SAMPLE_MODS_KEY in dp_data:
+        return_dict[SAMPLE_MODS_KEY] = dp_data[SAMPLE_MODS_KEY]
+
+    if CLI_KEY in dp_data:
+        return_dict[CLI_KEY] = dp_data[CLI_KEY]
+
     if PIPELINE_INTERFACES_KEY in dp_data:
+
         dp_data.setdefault(PIPELINE_INTERFACES_KEY, {})
-        return_dict[SAMPLE_PL_ARG] = dp_data.get(PIPELINE_INTERFACES_KEY).get("sample")
-        return_dict[PROJECT_PL_ARG] = dp_data.get(PIPELINE_INTERFACES_KEY).get(
-            "project"
-        )
+
+        if isinstance(dp_data.get(PIPELINE_INTERFACES_KEY), dict) and (
+            dp_data.get(PIPELINE_INTERFACES_KEY).get("sample")
+            or dp_data.get(PIPELINE_INTERFACES_KEY).get("project")
+        ):
+            # Support original nesting of pipeline interfaces under "sample" and "project"
+            return_dict[SAMPLE_PL_ARG] = dp_data.get(PIPELINE_INTERFACES_KEY).get(
+                "sample"
+            )
+            return_dict[PROJECT_PL_ARG] = dp_data.get(PIPELINE_INTERFACES_KEY).get(
+                "project"
+            )
+        else:
+            # infer pipeline type based from interface instead of nested keys: https://github.com/pepkit/looper/issues/465
+            all_pipeline_interfaces = dp_data.get(PIPELINE_INTERFACES_KEY)
+            sample_pifaces = []
+            project_pifaces = []
+            if isinstance(all_pipeline_interfaces, str):
+                all_pipeline_interfaces = [all_pipeline_interfaces]
+            for piface in all_pipeline_interfaces:
+                pipeline_type, piface_path = determine_pipeline_type(
+                    piface, looper_config_path
+                )
+                if pipeline_type == PipelineLevel.SAMPLE.value:
+                    sample_pifaces.append(piface_path)
+                elif pipeline_type == PipelineLevel.PROJECT.value:
+                    project_pifaces.append(piface_path)
+            if len(sample_pifaces) > 0:
+                return_dict[SAMPLE_PL_ARG] = sample_pifaces
+            if len(project_pifaces) > 0:
+                return_dict[PROJECT_PL_ARG] = project_pifaces
 
     else:
         _LOGGER.warning(
@@ -819,3 +913,33 @@ def inspect_looper_config_file(looper_config_dict) -> None:
     print("LOOPER INSPECT")
     for key, value in looper_config_dict.items():
         print(f"{key} {value}")
+
+
+def expand_nested_var_templates(var_templates_dict, namespaces):
+
+    "Takes all var_templates as a dict and recursively expands any paths."
+
+    result = {}
+
+    for k, v in var_templates_dict.items():
+        if isinstance(v, dict):
+            result[k] = expand_nested_var_templates(v, namespaces)
+        else:
+            result[k] = expandpath(v)
+
+    return result
+
+
+def render_nested_var_templates(var_templates_dict, namespaces):
+
+    "Takes all var_templates as a dict and recursively renders the jinja templates."
+
+    result = {}
+
+    for k, v in var_templates_dict.items():
+        if isinstance(v, dict):
+            result[k] = expand_nested_var_templates(v, namespaces)
+        else:
+            result[k] = jinja_render_template_strictly(v, namespaces)
+
+    return result

{looper-1.8.0.dist-info → looper-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: looper
-Version: 1.8.0
+Version: 1.9.0
 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
@@ -26,9 +26,10 @@ Requires-Dist: pipestat >=0.9.2
 Requires-Dist: peppy >=0.40.2
 Requires-Dist: pyyaml >=3.12
 Requires-Dist: rich >=9.10.0
-Requires-Dist: ubiquerg >=0.5.2
+Requires-Dist: ubiquerg >=0.8.1a1
 Requires-Dist: yacman ==0.9.3
-Requires-Dist: pydantic2-argparse >=0.9.2
+Requires-Dist: pydantic-argparse >=0.9.0
+Requires-Dist: psutil
 
 # <img src="docs/img/looper_logo.svg" alt="looper logo" height="70">
 

{looper-1.8.0.dist-info → looper-1.9.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
 looper/__init__.py,sha256=f_z9YY4ibOk7eyWoaViH_VaCXMlPQeiftbnibSFj-3E,1333
 looper/__main__.py,sha256=OOCmI-dPUvInnJHkHNMf54cblNJ3Yl9ELOwZcfOXmD8,240
-looper/_version.py,sha256=Oc_xF94AMAHKZkZlB5rBt1iO0TXWFalg65MP4T2qt-A,22
+looper/_version.py,sha256=qQzG7GXbJTUF2ruA1lKA3GEc5yhNqC4Eil6teqYTSTY,120
 looper/cli_divvy.py,sha256=J07x83sqC4jJeu3_yS6KOARPWmwKGAV7JvN33T5zDac,5907
-looper/cli_pydantic.py,sha256=QKG-rvy7ORkTivDIkrk4tWpVAcuxmUSZePV35hvag0k,13541
-looper/conductor.py,sha256=WAEtzZFElCK_mvsnaiGKnu5x6quYKsDMno6j6TuNG-g,31448
-looper/const.py,sha256=KbQD-Q62g61pUroEF4ogQerYhJE-xbt4cX9m15oYHTo,8682
-looper/divvy.py,sha256=SPoC7fpWHjC82NEKkpnObV1Koamt3M2tCmfAXpjdGRM,15399
+looper/cli_pydantic.py,sha256=bSnaCNKMgAg_PsYuguAzkf8JYuBTzLRI4QvnGdl_JE8,14017
+looper/conductor.py,sha256=DSpil080IYYqu-76ms25jrNSTmog0449tPXn0nK38Dw,34786
+looper/const.py,sha256=OscEELQsyLKlSrmwuXfyLRwpAUJUEpGD2UxBeLJDXgw,8703
+looper/divvy.py,sha256=5x8hV1lT5tEQdAUtVjn0rNwYnJroNij0RyDn-wHf4QE,15251
 looper/exceptions.py,sha256=r6SKKt-m8CXQnXGDnuiwoA6zBJhIZflygBKjX4RCloI,3419
-looper/looper.py,sha256=XomJIis4sFHOO5qEwzmyKT85X-lKNURX8yhOftTFmbY,30099
+looper/looper.py,sha256=ZWTulMz6NobnYFUjev513TJwXqknrb4_gZrV-a_fT9g,30041
 looper/parser_types.py,sha256=d3FHt54f9jo9VZMr5SQkbghcAdABqiYZW2JBGO5EBnw,2327
-looper/pipeline_interface.py,sha256=y46tB1_73d1FX8N1w4-GGvRBJ7rqhenuUYVtUfIhK5s,14974
+looper/pipeline_interface.py,sha256=dBXwsU59vR4qmUC59Bt3iM2187mXSDdysMNOhf63pPw,14922
 looper/plugins.py,sha256=MaMdPmK9U_4FkNJE5kccohBbY1i2qj1NTEucubFOJek,5747
 looper/processed_project.py,sha256=jZxoMYafvr-OHFxylc5ivGty1VwXBZhl0kgoFkY-174,9837
-looper/project.py,sha256=vgJVk_H7DahMrmcGyKv8tcb6rR1JTk2RcRRO1JV866E,37290
-looper/utils.py,sha256=TS7w46XwYzb6g3mA26xOUwDAuwBnJz3IHgAJRGHZaH8,29483
+looper/project.py,sha256=svkCChwpbFBSJZdYXWcOol0GZnWNWaw32yyye2ajkXw,34279
+looper/utils.py,sha256=KkXQ6igvuuWBhb-q3TzCUYf39aoWD9CGJ06f5zhVAyw,33799
 looper/command_models/DEVELOPER.md,sha256=eRxnrO-vqNJjExzamXKEq5wr_-Zw6PQEwkS9RPinYrk,2775
 looper/command_models/README.md,sha256=3RGegeZlTZYnhcHXRu6bdI_81WZom2q7QYMV-KGYY7U,588
 looper/command_models/__init__.py,sha256=6QWC2TewowEL7dATli5YpMmFWuXaLEPktofJCXkYUBI,187
 looper/command_models/arguments.py,sha256=emK7gc_fVgrSPHE2cShxJX05VrgOEn4H7szU8DBev7Q,8808
-looper/command_models/commands.py,sha256=ZZSI1mSDKejsYTr_q557MQRFrQZI8QTrXIxozxGs078,9724
+looper/command_models/commands.py,sha256=WieHeBGkZQlKFqUph6GEpd12dIUmJNJ4lLMgN2xeZJA,9723
 looper/default_config/divvy_config.yaml,sha256=wK5kLDGBV2wwoyqg2rl3X8SXjds4x0mwBUjUzF1Ln7g,1705
 looper/default_config/divvy_templates/localhost_bulker_template.sub,sha256=yn5VB9Brt7Hck9LT17hD2o8Kn-76gYJQk_A-8C1Gr4k,164
 looper/default_config/divvy_templates/localhost_docker_template.sub,sha256=XRr7AlR7-TP1L3hyBMfka_RgWRL9vzOlS5Kd1xSNwT0,183
@@ -60,9 +60,9 @@ looper/schemas/divvy_config_schema.yaml,sha256=7GJfKLc3VX4RGjHnOE1zxwsHXhj_ur9za
 looper/schemas/pipeline_interface_schema_generic.yaml,sha256=D16Rkpj03H9WnvA_N18iNU-hH_HwOuyESJ8Hk5hZSXc,1518
 looper/schemas/pipeline_interface_schema_project.yaml,sha256=-ZWyA0lKXWik3obuLNVk3IsAZYfbLVbCDvJnD-Fcluo,1567
 looper/schemas/pipeline_interface_schema_sample.yaml,sha256=x0OwVnijJpvm50DscvvJujdK4UAI7d71pqVemQS-D-0,1564
-looper-1.8.0.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
-looper-1.8.0.dist-info/METADATA,sha256=JNbHNlDh1i0dMn7wee_Mix6Hagjqq1iNRfvK6fe5lH8,1775
-looper-1.8.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-looper-1.8.0.dist-info/entry_points.txt,sha256=ejZpghZG3OoTK69u9rTW-yLyI6SC63bBTUb-Vw26HG4,87
-looper-1.8.0.dist-info/top_level.txt,sha256=I0Yf7djsoQAMzwHBbDiQi9hGtq4Z41_Ma5CX8qXG8Y8,7
-looper-1.8.0.dist-info/RECORD,,
+looper-1.9.0.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
+looper-1.9.0.dist-info/METADATA,sha256=h9Pdu_tGy4pTsX6m88wWWCF3eT5RsS96Sw9Kdq5wjLc,1798
+looper-1.9.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+looper-1.9.0.dist-info/entry_points.txt,sha256=ejZpghZG3OoTK69u9rTW-yLyI6SC63bBTUb-Vw26HG4,87
+looper-1.9.0.dist-info/top_level.txt,sha256=I0Yf7djsoQAMzwHBbDiQi9hGtq4Z41_Ma5CX8qXG8Y8,7
+looper-1.9.0.dist-info/RECORD,,

{looper-1.8.0.dist-info → looper-1.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any