looper 1.9.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

looper/_version.py

@@ -1,2 +1,2 @@
-__version__ = "1.9.1"
-# You must change the version in parser = pydantic2_argparse.ArgumentParser in cli_pydantic.py!!!
+__version__ = "2.0.0a1"
+# You must change the version in parser = pydantic_argparse.ArgumentParser in cli_pydantic.py!!!

looper/cli_pydantic.py

@@ -54,9 +54,11 @@ from .utils import (
     read_yaml_file,
     inspect_looper_config_file,
     is_PEP_file_type,
+    looper_config_tutorial,
 )
 
 from typing import List, Tuple
+from rich.console import Console
 
 
 def opt_attr_pair(name: str) -> Tuple[str, str]:
@@ -122,52 +124,60 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
         sys.exit(1)
 
     if subcommand_name == "init":
-        return int(
-            not initiate_looper_config(
-                dotfile_path(),
-                subcommand_args.pep_config,
-                subcommand_args.output_dir,
-                subcommand_args.sample_pipeline_interfaces,
-                subcommand_args.project_pipeline_interfaces,
-                subcommand_args.force_yes,
-            )
+
+        console = Console()
+        console.clear()
+        console.rule(f"\n[magenta]Looper initialization[/magenta]")
+        console.print(
+            "[bold]Would you like to follow a guided tutorial?[/bold]  [green]Y[/green] / [red]n[/red]..."
         )
 
+        selection = None
+        while selection not in ["y", "n"]:
+            selection = console.input("\nSelection: ").lower().strip()
+
+        if selection == "n":
+            console.clear()
+            return int(
+                not initiate_looper_config(
+                    dotfile_path(),
+                    subcommand_args.pep_config,
+                    subcommand_args.output_dir,
+                    subcommand_args.sample_pipeline_interfaces,
+                    subcommand_args.project_pipeline_interfaces,
+                    subcommand_args.force_yes,
+                )
+            )
+        else:
+            console.clear()
+            return int(looper_config_tutorial())
+
     if subcommand_name == "init_piface":
         sys.exit(int(not init_generic_pipeline()))
 
     _LOGGER.info("Looper version: {}\nCommand: {}".format(__version__, subcommand_name))
 
-    if subcommand_args.config_file is None:
-        looper_cfg_path = os.path.relpath(dotfile_path(), start=os.curdir)
-        try:
-            if subcommand_args.looper_config:
-                looper_config_dict = read_looper_config_file(
-                    subcommand_args.looper_config
-                )
+    looper_cfg_path = os.path.relpath(dotfile_path(), start=os.curdir)
+    try:
+        if subcommand_args.config:
+            looper_config_dict = read_looper_config_file(subcommand_args.config)
+        else:
+            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():
+            if looper_config_key == CLI_KEY:
+                cli_modifiers_dict = looper_config_item
             else:
-                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():
-                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)
-            _LOGGER.warning(
-                f"Looper config file does not exist. Use looper init to create one at {looper_cfg_path}."
-            )
-            sys.exit(1)
-    else:
+                setattr(subcommand_args, looper_config_key, looper_config_item)
+
+    except OSError:
+        parser.print_help(sys.stderr)
         _LOGGER.warning(
-            "This PEP configures looper through the project config. This approach is deprecated and will "
-            "be removed in future versions. Please use a looper config file. For more information see "
-            "looper.databio.org/en/latest/looper-config"
+            f"Looper config file does not exist. Use looper init to create one at {looper_cfg_path}."
         )
+        sys.exit(1)
 
     subcommand_args = enrich_args_via_cfg(
         subcommand_name,
@@ -191,12 +201,12 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
         subcommand_args.ignore_flags = True
 
     # Initialize project
-    if is_PEP_file_type(subcommand_args.config_file) and os.path.exists(
-        subcommand_args.config_file
+    if is_PEP_file_type(subcommand_args.pep_config) and os.path.exists(
+        subcommand_args.pep_config
     ):
         try:
             p = Project(
-                cfg=subcommand_args.config_file,
+                cfg=subcommand_args.pep_config,
                 amendments=subcommand_args.amend,
                 divcfg_path=divcfg,
                 runp=subcommand_name == "runp",
@@ -209,14 +219,14 @@ def run_looper(args: TopLevelParser, parser: ArgumentParser, test_args=None):
         except yaml.parser.ParserError as e:
             _LOGGER.error(f"Project config parse failed -- {e}")
             sys.exit(1)
-    elif is_pephub_registry_path(subcommand_args.config_file):
+    elif is_pephub_registry_path(subcommand_args.pep_config):
         if vars(subcommand_args)[SAMPLE_PL_ARG]:
             p = Project(
                 amendments=subcommand_args.amend,
                 divcfg_path=divcfg,
                 runp=subcommand_name == "runp",
                 project_dict=PEPHubClient()._load_raw_pep(
-                    registry_path=subcommand_args.config_file
+                    registry_path=subcommand_args.pep_config
                 ),
                 **{
                     attr: getattr(subcommand_args, attr)
@@ -252,7 +262,7 @@ 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(subcommand_args, "project", None)
+            if getattr(subcommand_args, "project", None) or subcommand_name == "runp"
             else prj._check_if_pipestat_configured()
         )
 
@@ -336,7 +346,7 @@ def main(test_args=None) -> None:
         prog="looper",
         description="Looper: A job submitter for Portable Encapsulated Projects",
         add_help=True,
-        version="1.9.1",
+        version="2.0.0a1",
     )
 
     parser = add_short_arguments(parser, ArgumentEnum)

looper/command_models/arguments.py

@@ -162,13 +162,9 @@ class ArgumentEnum(enum.Enum):
         default=(int, None),
         description="Skip samples by numerical index",
     )
-    CONFIG_FILE = Argument(
-        name="config_file",
-        default=(str, None),
-        description="Project configuration file",
-    )
-    LOOPER_CONFIG = Argument(
-        name="looper_config",
+    CONFIG = Argument(
+        name="config",
+        alias="-c",
         default=(str, None),
         description="Looper configuration file (YAML)",
     )
@@ -237,7 +233,6 @@ class ArgumentEnum(enum.Enum):
     )
     COMPUTE = Argument(
         name="compute",
-        alias="-c",
         default=(List, []),
         description="List of key-value pairs (k1=v1)",
     )

looper/command_models/commands.py

@@ -53,8 +53,7 @@ SHARED_ARGUMENTS = [
     ArgumentEnum.SKIP.value,
     ArgumentEnum.PEP_CONFIG.value,
     ArgumentEnum.OUTPUT_DIR.value,
-    ArgumentEnum.CONFIG_FILE.value,
-    ArgumentEnum.LOOPER_CONFIG.value,
+    ArgumentEnum.CONFIG.value,
     ArgumentEnum.SAMPLE_PIPELINE_INTERFACES.value,
     ArgumentEnum.PROJECT_PIPELINE_INTERFACES.value,
     ArgumentEnum.PIPESTAT.value,

looper/conductor.py

@@ -198,6 +198,9 @@ class SubmissionConductor(object):
 
         self.collate = collate
         self.section_key = PROJECT_PL_KEY if self.collate else SAMPLE_PL_KEY
+        self.pipeline_interface_type = (
+            "project_interface" if self.collate else "sample_interface"
+        )
         self.pl_iface = pipeline_interface
         self.pl_name = self.pl_iface.pipeline_name
         self.prj = prj
@@ -681,7 +684,11 @@ class SubmissionConductor(object):
             pipeline=self.pl_iface,
             compute=self.prj.dcc.compute,
         )
-        templ = self.pl_iface["command_template"]
+
+        if self.pipeline_interface_type is None:
+            templ = self.pl_iface["command_template"]
+        else:
+            templ = self.pl_iface[self.pipeline_interface_type]["command_template"]
         if not self.override_extra:
             extras_template = (
                 EXTRA_PROJECT_CMD_TEMPLATE

looper/pipeline_interface.py

@@ -56,15 +56,6 @@ class PipelineInterface(YAMLConfigManager):
             )
         self.update(config)
         self._validate(schema_src=PIFACE_SCHEMA_SRC)
-        if "path" in self:
-            warn(
-                message="'path' specification as a top-level pipeline "
-                "interface key is deprecated and will be removed with "
-                "the next release. Please use 'paths' section "
-                "from now on.",
-                category=DeprecationWarning,
-            )
-            self._expand_paths(["path"])
         self._expand_paths(["compute", "dynamic_variables_script_path"])
 
     @property

looper/project.py

@@ -413,10 +413,12 @@ class Project(peppyProject):
                 pipestat_config_path = self._check_for_existing_pipestat_config(piface)
 
                 if not pipestat_config_path:
-                    self._create_pipestat_config(piface)
+                    self._create_pipestat_config(piface, pipeline_type)
                 else:
                     piface.psm = PipestatManager(
-                        config_file=pipestat_config_path, multi_pipelines=True
+                        config_file=pipestat_config_path,
+                        multi_pipelines=True,
+                        pipeline_type="sample",
                     )
 
         elif pipeline_type == PipelineLevel.PROJECT.value:
@@ -426,10 +428,12 @@ class Project(peppyProject):
                 )
 
                 if not pipestat_config_path:
-                    self._create_pipestat_config(prj_piface)
+                    self._create_pipestat_config(prj_piface, pipeline_type)
                 else:
                     prj_piface.psm = PipestatManager(
-                        config_file=pipestat_config_path, multi_pipelines=True
+                        config_file=pipestat_config_path,
+                        multi_pipelines=True,
+                        pipeline_type="project",
                     )
         else:
             _LOGGER.error(
@@ -469,7 +473,7 @@ class Project(peppyProject):
         else:
             return None
 
-    def _create_pipestat_config(self, piface):
+    def _create_pipestat_config(self, piface, pipeline_type):
         """
         Each piface needs its own config file and associated psm
         """
@@ -512,8 +516,6 @@ class Project(peppyProject):
             pipestat_config_dict.update({"pipeline_name": piface.data["pipeline_name"]})
         else:
             pipeline_name = None
-        if "pipeline_type" in piface.data:
-            pipestat_config_dict.update({"pipeline_type": piface.data["pipeline_type"]})
 
         # Warn user if there is a mismatch in pipeline_names from sources!!!
         if pipeline_name != output_schema_pipeline_name:

looper/schemas/pipeline_interface_schema_generic.yaml

@@ -9,12 +9,20 @@ properties:
     type: string
     enum: ["project", "sample"]
     description: "type of the pipeline, either 'project' or 'sample'"
-  command_template:
-    type: string
-    description: "Jinja2-like template to construct the command to run"
-  path:
-    type: string
-    description: "path to the pipeline program. Relative to pipeline interface file or absolute."
+  sample_interface:
+    type: object
+    description: "Section that defines compute environment settings"
+    properties:
+      command_template:
+        type: string
+        description: "Jinja2-like template to construct the command to run"
+  project_interface:
+    type: object
+    description: "Section that defines compute environment settings"
+    properties:
+      command_template:
+        type: string
+        description: "Jinja2-like template to construct the command to run"
   compute:
     type: object
     description: "Section that defines compute environment settings"

looper/utils.py

@@ -20,7 +20,9 @@ from yacman import load_yaml
 
 from .const import *
 from .command_models.commands import SUPPORTED_COMMANDS
-from .exceptions import MisconfigurationException
+from .exceptions import MisconfigurationException, PipelineInterfaceConfigError
+from rich.console import Console
+from rich.pretty import pprint
 
 _LOGGER = getLogger(__name__)
 
@@ -273,7 +275,7 @@ def enrich_args_via_cfg(
     """
     cfg_args_all = (
         _get_subcommand_args(subcommand_name, parser_args)
-        if os.path.exists(parser_args.config_file)
+        if os.path.exists(parser_args.pep_config)
         else dict()
     )
 
@@ -360,7 +362,7 @@ def _get_subcommand_args(subcommand_name, parser_args):
     """
     args = dict()
     cfg = peppyProject(
-        parser_args.config_file,
+        parser_args.pep_config,
         defer_samples_creation=True,
         amendments=parser_args.amend,
     )
@@ -402,40 +404,66 @@ def _get_subcommand_args(subcommand_name, parser_args):
     return args
 
 
-def init_generic_pipeline():
+def init_generic_pipeline(pipelinepath: Optional[str] = None):
     """
     Create generic pipeline interface
     """
-    try:
-        os.makedirs("pipeline")
-    except FileExistsError:
-        pass
+    console = Console()
 
     # Destination one level down from CWD in pipeline folder
-    dest_file = os.path.join(os.getcwd(), "pipeline", LOOPER_GENERIC_PIPELINE)
+    if not pipelinepath:
+        try:
+            os.makedirs("pipeline")
+        except FileExistsError:
+            pass
+
+        dest_file = os.path.join(os.getcwd(), "pipeline", LOOPER_GENERIC_PIPELINE)
+    else:
+        if os.path.isabs(pipelinepath):
+            dest_file = pipelinepath
+        else:
+            dest_file = os.path.join(os.getcwd(), os.path.relpath(pipelinepath))
+        try:
+            os.makedirs(os.path.dirname(dest_file))
+        except FileExistsError:
+            pass
 
     # Create Generic Pipeline Interface
     generic_pipeline_dict = {
         "pipeline_name": "default_pipeline_name",
-        "pipeline_type": "sample",
         "output_schema": "output_schema.yaml",
-        "var_templates": {"pipeline": "{looper.piface_dir}/pipeline.sh"},
-        "command_template": "{pipeline.var_templates.pipeline} {sample.file} "
-        "--output-parent {looper.sample_output_folder}",
+        "var_templates": {"pipeline": "{looper.piface_dir}/count_lines.sh"},
+        "sample_interface": {
+            "command_template": "{pipeline.var_templates.pipeline} {sample.file} "
+            "--output-parent {looper.sample_output_folder}"
+        },
     }
 
+    console.rule(f"\n[magenta]Pipeline Interface[/magenta]")
     # Write file
     if not os.path.exists(dest_file):
+        pprint(generic_pipeline_dict, expand_all=True)
+
         with open(dest_file, "w") as file:
             yaml.dump(generic_pipeline_dict, file)
-        print(f"Pipeline interface successfully created at: {dest_file}")
+
+        console.print(
+            f"Pipeline interface successfully created at: [yellow]{dest_file}[/yellow]"
+        )
+
     else:
-        print(
-            f"Pipeline interface file already exists `{dest_file}`. Skipping creation.."
+        console.print(
+            f"Pipeline interface file already exists [yellow]`{dest_file}`[/yellow]. Skipping creation.."
         )
 
     # Create Generic Output Schema
-    dest_file = os.path.join(os.getcwd(), "pipeline", LOOPER_GENERIC_OUTPUT_SCHEMA)
+    if not pipelinepath:
+        dest_file = os.path.join(os.getcwd(), "pipeline", LOOPER_GENERIC_OUTPUT_SCHEMA)
+    else:
+        dest_file = os.path.join(
+            os.path.dirname(dest_file), LOOPER_GENERIC_OUTPUT_SCHEMA
+        )
+
     generic_output_schema_dict = {
         "pipeline_name": "default_pipeline_name",
         "samples": {
@@ -445,27 +473,45 @@ def init_generic_pipeline():
             }
         },
     }
+
+    console.rule(f"\n[magenta]Output Schema[/magenta]")
     # Write file
     if not os.path.exists(dest_file):
+        pprint(generic_output_schema_dict, expand_all=True)
         with open(dest_file, "w") as file:
             yaml.dump(generic_output_schema_dict, file)
-        print(f"Output schema successfully created at: {dest_file}")
+        console.print(
+            f"Output schema successfully created at: [yellow]{dest_file}[/yellow]"
+        )
     else:
-        print(f"Output schema file already exists `{dest_file}`. Skipping creation..")
+        console.print(
+            f"Output schema file already exists [yellow]`{dest_file}`[/yellow]. Skipping creation.."
+        )
 
+    console.rule(f"\n[magenta]Example Pipeline Shell Script[/magenta]")
     # Create Generic countlines.sh
-    dest_file = os.path.join(os.getcwd(), "pipeline", LOOPER_GENERIC_COUNT_LINES)
+
+    if not pipelinepath:
+        dest_file = os.path.join(os.getcwd(), "pipeline", LOOPER_GENERIC_COUNT_LINES)
+    else:
+        dest_file = os.path.join(os.path.dirname(dest_file), LOOPER_GENERIC_COUNT_LINES)
+
     shell_code = """#!/bin/bash
 linecount=`wc -l $1 | sed -E 's/^[[:space:]]+//' | cut -f1 -d' '`
 pipestat report -r $2 -i 'number_of_lines' -v $linecount -c $3
 echo "Number of lines: $linecount"
     """
     if not os.path.exists(dest_file):
+        console.print(shell_code)
         with open(dest_file, "w") as file:
             file.write(shell_code)
-        print(f"count_lines.sh successfully created at: {dest_file}")
+        console.print(
+            f"count_lines.sh successfully created at: [yellow]{dest_file}[/yellow]"
+        )
     else:
-        print(f"count_lines.sh file already exists `{dest_file}`. Skipping creation..")
+        console.print(
+            f"count_lines.sh file already exists [yellow]`{dest_file}`[/yellow]. Skipping creation.."
+        )
 
     return True
 
@@ -500,8 +546,14 @@ def initiate_looper_config(
     :param bool force: whether the existing file should be overwritten
     :return bool: whether the file was initialized
     """
+    console = Console()
+    console.clear()
+    console.rule(f"\n[magenta]Looper initialization[/magenta]")
+
     if os.path.exists(looper_config_path) and not force:
-        print(f"Can't initialize, file exists: {looper_config_path}")
+        console.print(
+            f"[red]Can't initialize, file exists:[/red] [yellow]{looper_config_path}[/yellow]"
+        )
         return False
 
     if pep_path:
@@ -521,24 +573,171 @@ def initiate_looper_config(
     if not output_dir:
         output_dir = "."
 
+    if sample_pipeline_interfaces is None or sample_pipeline_interfaces == []:
+        sample_pipeline_interfaces = "pipeline_interface1.yaml"
+
+    if project_pipeline_interfaces is None or project_pipeline_interfaces == []:
+        project_pipeline_interfaces = "pipeline_interface2.yaml"
+
     looper_config_dict = {
         "pep_config": os.path.relpath(pep_path),
         "output_dir": output_dir,
-        "pipeline_interfaces": {
-            "sample": sample_pipeline_interfaces,
-            "project": project_pipeline_interfaces,
-        },
+        "pipeline_interfaces": [
+            sample_pipeline_interfaces,
+            project_pipeline_interfaces,
+        ],
     }
 
+    pprint(looper_config_dict, expand_all=True)
+
     with open(looper_config_path, "w") as dotfile:
         yaml.dump(looper_config_dict, dotfile)
-    print(f"Initialized looper config file: {looper_config_path}")
+    console.print(
+        f"Initialized looper config file: [yellow]{looper_config_path}[/yellow]"
+    )
+
+    return True
+
+
+def looper_config_tutorial():
+    """
+    Prompt a user through configuring a .looper.yaml file for a new project.
+
+    :return bool: whether the file was initialized
+    """
+
+    console = Console()
+    console.clear()
+    console.rule(f"\n[magenta]Looper initialization[/magenta]")
+
+    looper_cfg_path = ".looper.yaml"  # not changeable
+
+    if os.path.exists(looper_cfg_path):
+        console.print(
+            f"[bold red]File exists at '{looper_cfg_path}'. Delete it to re-initialize. \n[/bold red]"
+        )
+        raise SystemExit
+
+    cfg = {}
+
+    console.print(
+        "This utility will walk you through creating a [yellow].looper.yaml[/yellow] file."
+    )
+    console.print("See [yellow]`looper init --help`[/yellow] for details.")
+    console.print("Use [yellow]`looper run`[/yellow] afterwards to run the pipeline.")
+    console.print("Press [yellow]^C[/yellow] at any time to quit.\n")
+
+    console.input("> ... ")
+
+    DEFAULTS = {  # What you get if you just press enter
+        "pep_config": "databio/example",
+        "output_dir": "results",
+        "piface_path": "pipeline/pipeline_interface.yaml",
+        "project_name": os.path.basename(os.getcwd()),
+    }
+
+    creating = True
+
+    while creating:
+        cfg["project_name"] = (
+            console.input(
+                f"Project name: [yellow]({DEFAULTS['project_name']})[/yellow] >"
+            )
+            or DEFAULTS["project_name"]
+        )
+
+        cfg["pep_config"] = (
+            console.input(
+                f"Registry path or file path to PEP: [yellow]({DEFAULTS['pep_config']})[/yellow] >"
+            )
+            or DEFAULTS["pep_config"]
+        )
+
+        if not os.path.exists(cfg["pep_config"]):
+            console.print(
+                f"Warning: PEP file does not exist at [yellow]'{cfg['pep_config']}[/yellow]'"
+            )
+
+        cfg["output_dir"] = (
+            console.input(
+                f"Path to output directory: [yellow]({DEFAULTS['output_dir']})[/yellow] >"
+            )
+            or DEFAULTS["output_dir"]
+        )
+
+        add_more_pifaces = True
+        piface_paths = []
+        while add_more_pifaces:
+            piface_path = (
+                console.input(
+                    "Add each path to a pipeline interface: [yellow](pipeline_interface.yaml)[/yellow] >"
+                )
+                or None
+            )
+            if piface_path is None:
+                if piface_paths == []:
+                    piface_paths.append(DEFAULTS["piface_path"])
+                add_more_pifaces = False
+            else:
+                piface_paths.append(piface_path)
+
+        console.print("\n")
+
+        console.print(
+            f"""\
+    [yellow]pep_config:[/yellow] {cfg['pep_config']}
+    [yellow]output_dir:[/yellow] {cfg['output_dir']}
+    [yellow]pipeline_interfaces:[/yellow]
+      - {piface_paths}
+    """
+        )
+
+        console.print(
+            "[bold]Does this look good?[/bold]  [bold green]Y[/bold green]/[red]n[/red]..."
+        )
+        selection = None
+        while selection not in ["y", "n"]:
+            selection = console.input("\nSelection: ").lower().strip()
+        if selection == "n":
+            console.print("Starting over...")
+            pass
+        if selection == "y":
+            creating = False
+
+    for piface_path in piface_paths:
+        if not os.path.exists(piface_path):
+            console.print(
+                f"[bold red]Warning:[/bold red] File does not exist at [yellow]{piface_path}[/yellow]"
+            )
+            console.print(
+                "Do you wish to initialize a generic pipeline interface? [bold green]Y[/bold green]/[red]n[/red]..."
+            )
+            selection = None
+            while selection not in ["y", "n"]:
+                selection = console.input("\nSelection: ").lower().strip()
+            if selection == "n":
+                console.print(
+                    "Use command [yellow]`looper init_piface`[/yellow] to create a generic pipeline interface."
+                )
+            if selection == "y":
+                init_generic_pipeline(pipelinepath=piface_path)
+
+    console.print(f"Writing config file to [yellow]{looper_cfg_path}[/yellow]")
+
+    looper_config_dict = {}
+    looper_config_dict["pep_config"] = cfg["pep_config"]
+    looper_config_dict["output_dir"] = cfg["output_dir"]
+    looper_config_dict["pipeline_interfaces"] = [piface_paths]
+
+    with open(looper_cfg_path, "w") as fp:
+        yaml.dump(looper_config_dict, fp)
+
     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
+    Read pipeline interface from disk and determine if it contains "sample_interface", "project_interface" or both
 
 
     :param str piface_path: path to pipeline_interface
@@ -558,9 +757,18 @@ def determine_pipeline_type(piface_path: str, looper_config_path: str):
     except FileNotFoundError:
         return None, None
 
-    pipeline_type = piface_dict.get("pipeline_type", None)
+    pipeline_types = []
+    if piface_dict.get("sample_interface", None):
+        pipeline_types.append(PipelineLevel.SAMPLE.value)
+    if piface_dict.get("project_interface", None):
+        pipeline_types.append(PipelineLevel.PROJECT.value)
+
+    if pipeline_types == []:
+        raise PipelineInterfaceConfigError(
+            f"sample_interface and/or project_interface must be defined in each pipeline interface."
+        )
 
-    return pipeline_type, piface_path
+    return pipeline_types, piface_path
 
 
 def read_looper_config_file(looper_config_path: str) -> dict:
@@ -579,15 +787,8 @@ def read_looper_config_file(looper_config_path: str) -> dict:
         dp_data = yaml.safe_load(dotfile)
 
     if PEP_CONFIG_KEY in dp_data:
-        # Looper expects the config path to live at looper.config_file
-        # However, user may wish to access the pep at looper.pep_config
-        return_dict[PEP_CONFIG_FILE_KEY] = dp_data[PEP_CONFIG_KEY]
         return_dict[PEP_CONFIG_KEY] = dp_data[PEP_CONFIG_KEY]
 
-    # TODO: delete it in looper 2.0
-    elif DOTFILE_CFG_PTH_KEY in dp_data:
-        return_dict[PEP_CONFIG_FILE_KEY] = dp_data[DOTFILE_CFG_PTH_KEY]
-
     else:
         raise MisconfigurationException(
             f"Looper dotfile ({looper_config_path}) is missing '{PEP_CONFIG_KEY}' key"
@@ -613,36 +814,25 @@ def read_looper_config_file(looper_config_path: str) -> dict:
 
         dp_data.setdefault(PIPELINE_INTERFACES_KEY, {})
 
-        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"
+        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_types, piface_path = determine_pipeline_type(
+                piface, looper_config_path
             )
-        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:
+            if pipeline_types is not None:
+                if PipelineLevel.SAMPLE.value in pipeline_types:
                     sample_pifaces.append(piface_path)
-                elif pipeline_type == PipelineLevel.PROJECT.value:
+                if PipelineLevel.PROJECT.value in pipeline_types:
                     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
+        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(

{looper-1.9.1.dist-info → looper-2.0.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: looper
-Version: 1.9.1
+Version: 2.0.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
@@ -23,7 +23,7 @@ Requires-Dist: logmuse >=0.2.0
 Requires-Dist: pandas >=2.0.2
 Requires-Dist: pephubclient >=0.4.0
 Requires-Dist: pipestat >=0.9.2
-Requires-Dist: peppy <=0.40.2,>=0.40.0
+Requires-Dist: peppy >=0.40.2
 Requires-Dist: pyyaml >=3.12
 Requires-Dist: rich >=9.10.0
 Requires-Dist: ubiquerg >=0.8.1a1

{looper-1.9.1.dist-info → looper-2.0.0a1.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=Ghy5rA1bB9z5xOMUOvtP6NkyAM_ZJj_GadLFiB5IJIQ,120
+looper/_version.py,sha256=wJ2KiFRb6QXaKu1tfxwKmo9CE2xP4f3BkEUYoIJeUkQ,121
 looper/cli_divvy.py,sha256=J07x83sqC4jJeu3_yS6KOARPWmwKGAV7JvN33T5zDac,5907
-looper/cli_pydantic.py,sha256=xDYj1ABJNiHg2RJi6i5LH2DhPRq0vz5Q9DBVNk1IlK8,14017
-looper/conductor.py,sha256=DSpil080IYYqu-76ms25jrNSTmog0449tPXn0nK38Dw,34786
+looper/cli_pydantic.py,sha256=saAD0dwizLi_VajVKElQmYRqtn0Yyl_r712znxZMxRQ,14209
+looper/conductor.py,sha256=oNfqANA2tIhQTAQFxd-rQ4ccPA60D933EGo3rfbJGFo,35061
 looper/const.py,sha256=OscEELQsyLKlSrmwuXfyLRwpAUJUEpGD2UxBeLJDXgw,8703
 looper/divvy.py,sha256=5x8hV1lT5tEQdAUtVjn0rNwYnJroNij0RyDn-wHf4QE,15251
 looper/exceptions.py,sha256=r6SKKt-m8CXQnXGDnuiwoA6zBJhIZflygBKjX4RCloI,3419
 looper/looper.py,sha256=ZWTulMz6NobnYFUjev513TJwXqknrb4_gZrV-a_fT9g,30041
 looper/parser_types.py,sha256=d3FHt54f9jo9VZMr5SQkbghcAdABqiYZW2JBGO5EBnw,2327
-looper/pipeline_interface.py,sha256=dBXwsU59vR4qmUC59Bt3iM2187mXSDdysMNOhf63pPw,14922
+looper/pipeline_interface.py,sha256=mN4-XICyZzuVLTOq3b0ijppYe6ib_Ljlyf6KxZCJh2A,14537
 looper/plugins.py,sha256=MaMdPmK9U_4FkNJE5kccohBbY1i2qj1NTEucubFOJek,5747
 looper/processed_project.py,sha256=jZxoMYafvr-OHFxylc5ivGty1VwXBZhl0kgoFkY-174,9837
-looper/project.py,sha256=svkCChwpbFBSJZdYXWcOol0GZnWNWaw32yyye2ajkXw,34279
-looper/utils.py,sha256=KkXQ6igvuuWBhb-q3TzCUYf39aoWD9CGJ06f5zhVAyw,33799
+looper/project.py,sha256=SFHdi58eRBWtye5lUFhwzBcG7ejrMurmDzmkrC3XAic,34339
+looper/utils.py,sha256=VXKaEYXW0XEQNy__hNBv42i-sz5qB7QiwpXzhXs_3Wk,39556
 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=WieHeBGkZQlKFqUph6GEpd12dIUmJNJ4lLMgN2xeZJA,9723
+looper/command_models/arguments.py,sha256=sRrJWCSQmnjGLnOo-Wl6_PnvTZz8VIWII79svI3BqFk,8653
+looper/command_models/commands.py,sha256=EvKyjNdUBspXnOUMprxIY0C4VPka2PBj8CJgtd5Ya9w,9680
 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
@@ -57,12 +57,12 @@ looper/jinja_templates_old/status.html,sha256=FBH2hqw3tVJgmR1kY3Cz5SQRHmnH6JqaDL
 looper/jinja_templates_old/status_table.html,sha256=VbHax7cGENIfVnU-O9p2ELSAJIONJ41m-mHJBy4r4dQ,3271
 looper/jinja_templates_old/status_table_no_links.html,sha256=vrPNCKen-yrkM_dg13f0yCVyeJHCQVNNY_bchUW_sVY,2396
 looper/schemas/divvy_config_schema.yaml,sha256=7GJfKLc3VX4RGjHnOE1zxwsHXhj_ur9za6dKdfJTFkc,450
-looper/schemas/pipeline_interface_schema_generic.yaml,sha256=D16Rkpj03H9WnvA_N18iNU-hH_HwOuyESJ8Hk5hZSXc,1518
+looper/schemas/pipeline_interface_schema_generic.yaml,sha256=3YfKFyRUIwxG41FEidR1dXe9IU6ye51LSUBfSpmMuss,1773
 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.9.1.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
-looper-1.9.1.dist-info/METADATA,sha256=hacnQb4KXUjACK_vJRTzff7XXcILGXypa-y10ic3weU,1807
-looper-1.9.1.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
-looper-1.9.1.dist-info/entry_points.txt,sha256=ejZpghZG3OoTK69u9rTW-yLyI6SC63bBTUb-Vw26HG4,87
-looper-1.9.1.dist-info/top_level.txt,sha256=I0Yf7djsoQAMzwHBbDiQi9hGtq4Z41_Ma5CX8qXG8Y8,7
-looper-1.9.1.dist-info/RECORD,,
+looper-2.0.0a1.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
+looper-2.0.0a1.dist-info/METADATA,sha256=OZPEqy9PPCjzJ110u-HazaRkaUIiuesCZMC3jpfl2vQ,1800
+looper-2.0.0a1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+looper-2.0.0a1.dist-info/entry_points.txt,sha256=ejZpghZG3OoTK69u9rTW-yLyI6SC63bBTUb-Vw26HG4,87
+looper-2.0.0a1.dist-info/top_level.txt,sha256=I0Yf7djsoQAMzwHBbDiQi9hGtq4Z41_Ma5CX8qXG8Y8,7
+looper-2.0.0a1.dist-info/RECORD,,

{looper-1.9.1.dist-info → looper-2.0.0a1.dist-info}/WHEEL

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