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

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,12 +13,17 @@ 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.error_wrappers import ValidationError
+from pydantic import ValidationError
+from yacman import load_yaml
+from yaml.parser import ParserError
 
 from .const import *
-from .exceptions import MisconfigurationException, RegistryPathException
+from .command_models.commands import SUPPORTED_COMMANDS
+from .exceptions import MisconfigurationException, PipelineInterfaceConfigError
+from rich.console import Console
+from rich.pretty import pprint
 
 _LOGGER = getLogger(__name__)
 
@@ -94,7 +98,9 @@ def fetch_sample_flags(prj, sample, pl_name, flag_dir=None):
     return [
         x
         for x in folder_contents
-        if os.path.splitext(x)[1] == ".flag" and os.path.basename(x).startswith(pl_name)
+        if os.path.splitext(x)[1] == ".flag"
+        and os.path.basename(x).startswith(pl_name)
+        and sample.sample_name in x
     ]
 
 
@@ -250,22 +256,54 @@ def read_yaml_file(filepath):
     return data
 
 
-def enrich_args_via_cfg(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.
+    Read in a looper dotfile, pep config and set arguments.
 
-    Priority order: CLI > dotfile/config > parser default
+    Priority order: CLI > dotfile/config > pep_config > parser default
 
+    :param subcommand name: the name of the command used
     :param argparse.Namespace parser_args: parsed args by the original parser
-    :param argparse.Namespace aux_parser: parsed args by the a parser
+    :param argparse.Namespace aux_parser: parsed args by the argument parser
         with defaults suppressed
+    :param dict test_args: dict of args used for pytesting
+    :param dict cli_modifiers: dict of args existing if user supplied cli args in looper config file
     :return argparse.Namespace: selected argument values
     """
+
+    # Did the user provide arguments in the PEP config?
     cfg_args_all = (
-        _get_subcommand_args(parser_args)
-        if os.path.exists(parser_args.config_file)
+        _get_subcommand_args(subcommand_name, parser_args)
+        if os.path.exists(parser_args.pep_config)
         else dict()
     )
+    if not cfg_args_all:
+        cfg_args_all = {}
+
+    # Did the user provide arguments/modifiers in the looper config file?
+    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)
@@ -273,23 +311,51 @@ def enrich_args_via_cfg(parser_args, aux_parser, test_args=None):
     else:
         cli_args, _ = aux_parser.parse_known_args()
 
-    for dest in vars(parser_args):
-        if dest not in POSITIONAL or not hasattr(result, dest):
-            if dest in cli_args:
-                x = getattr(cli_args, dest)
-                r = convert_value(x) if isinstance(x, str) else x
-            elif cfg_args_all is not None and dest in cfg_args_all:
-                if isinstance(cfg_args_all[dest], list):
-                    r = [convert_value(i) for i in cfg_args_all[dest]]
+    # If any CLI args were provided, make sure they take priority
+    if cli_args:
+        r = getattr(cli_args, subcommand_name)
+        for k, v in cfg_args_all.items():
+            if k in r:
+                cfg_args_all[k] = getattr(r, k)
+
+    def set_single_arg(argname, default_source_namespace, result_namespace):
+        if argname not in POSITIONAL or not hasattr(result, argname):
+            if argname in cli_args:
+                cli_provided_value = getattr(cli_args, argname)
+                r = (
+                    convert_value(cli_provided_value)
+                    if isinstance(cli_provided_value, str)
+                    else cli_provided_value
+                )
+            elif cfg_args_all is not None and argname in cfg_args_all:
+                if isinstance(cfg_args_all[argname], list):
+                    r = [convert_value(i) for i in cfg_args_all[argname]]
+                elif isinstance(cfg_args_all[argname], dict):
+                    r = cfg_args_all[argname]
                 else:
-                    r = convert_value(cfg_args_all[dest])
+                    r = convert_value(cfg_args_all[argname])
             else:
-                r = getattr(parser_args, dest)
-            setattr(result, dest, r)
+                r = getattr(default_source_namespace, argname)
+            setattr(result_namespace, argname, r)
+
+    for top_level_argname in vars(parser_args):
+        if top_level_argname not in [cmd.name for cmd in SUPPORTED_COMMANDS]:
+            # this argument is a top-level argument
+            set_single_arg(top_level_argname, parser_args, result)
+        else:
+            # this argument actually is a subcommand
+            enriched_command_namespace = argparse.Namespace()
+            command_namespace = getattr(parser_args, top_level_argname)
+            if command_namespace:
+                for argname in vars(command_namespace):
+                    set_single_arg(
+                        argname, command_namespace, enriched_command_namespace
+                    )
+            setattr(result, top_level_argname, enriched_command_namespace)
     return result
 
 
-def _get_subcommand_args(parser_args):
+def _get_subcommand_args(subcommand_name, parser_args):
     """
     Get the union of values for the subcommand arguments from
     Project.looper, Project.looper.cli.<subcommand> and Project.looper.cli.all.
@@ -304,7 +370,7 @@ def _get_subcommand_args(parser_args):
     """
     args = dict()
     cfg = peppyProject(
-        parser_args.config_file,
+        parser_args.pep_config,
         defer_samples_creation=True,
         amendments=parser_args.amend,
     )
@@ -321,8 +387,8 @@ def _get_subcommand_args(parser_args):
                 else dict()
             )
             args.update(
-                cfg_args[parser_args.command] or dict()
-                if parser_args.command in cfg_args
+                cfg_args[subcommand_name] or dict()
+                if subcommand_name in cfg_args
                 else dict()
             )
         except (TypeError, KeyError, AttributeError, ValueError) as e:
@@ -346,40 +412,65 @@ def _get_subcommand_args(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}",
+        "sample_interface": {
+            "command_template": "{looper.piface_dir}/count_lines.sh {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": {
@@ -389,27 +480,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
 
@@ -444,12 +553,18 @@ 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:
-        if is_registry_path(pep_path):
+        if is_pephub_registry_path(pep_path):
             pass
         else:
             pep_path = expandpath(pep_path)
@@ -465,21 +580,196 @@ 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")
+
+    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()),
+    }
+
+    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"]) and not is_pephub_registry_path(
+        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}
+"""
+    )
+
+    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 it contains "sample_interface", "project_interface" or both
+
+
+    :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
+    try:
+        piface_path = expandpath(piface_path)
+    except TypeError as e:
+        _LOGGER.warning(
+            f"Pipeline interface not found at given path: {piface_path}. Type Error: "
+            + str(e)
+        )
+        return None, None
+
+    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:
+        _LOGGER.warning(f"Pipeline interface not found at given path: {piface_path}")
+        return None, 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_types, piface_path
+
+
 def read_looper_config_file(looper_config_path: str) -> dict:
     """
     Read Looper config file which includes:
@@ -492,19 +782,18 @@ def read_looper_config_file(looper_config_path: str) -> dict:
     :raise MisconfigurationException: incorrect configuration.
     """
     return_dict = {}
-    with open(looper_config_path, "r") as dotfile:
-        dp_data = yaml.safe_load(dotfile)
+
+    try:
+        with open(looper_config_path, "r") as dotfile:
+            dp_data = yaml.safe_load(dotfile)
+    except ParserError as e:
+        _LOGGER.warning(
+            "Could not load looper config file due to the following exception"
+        )
+        raise ParserError(context=str(e))
 
     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"
@@ -520,12 +809,35 @@ 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"
-        )
+
+        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
+            )
+            if pipeline_types is not None:
+                if PipelineLevel.SAMPLE.value in pipeline_types:
+                    sample_pifaces.append(piface_path)
+                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
 
     else:
         _LOGGER.warning(
@@ -537,12 +849,26 @@ def read_looper_config_file(looper_config_path: str) -> dict:
 
     # Expand paths in case ENV variables are used
     for k, v in return_dict.items():
+        if k == SAMPLE_PL_ARG or k == PROJECT_PL_ARG:
+            # Pipeline interfaces are resolved at a later point. Do it there only to maintain consistency. #474
+
+            pass
         if isinstance(v, str):
             v = expandpath(v)
-            if not os.path.isabs(v) and not is_registry_path(v):
-                return_dict[k] = os.path.join(config_dir_path, v)
-            else:
+            # TODO this is messy because is_pephub_registry needs to fail on anything NOT a pephub registry path
+            # https://github.com/pepkit/ubiquerg/issues/43
+            if is_PEP_file_type(v):
+                if not os.path.isabs(v):
+                    return_dict[k] = os.path.join(config_dir_path, v)
+                else:
+                    return_dict[k] = v
+            elif is_pephub_registry_path(v):
                 return_dict[k] = v
+            else:
+                if not os.path.isabs(v):
+                    return_dict[k] = os.path.join(config_dir_path, v)
+                else:
+                    return_dict[k] = v
 
     return return_dict
 
@@ -575,19 +901,23 @@ def dotfile_path(directory=os.getcwd(), must_exist=False):
         cur_dir = parent_dir
 
 
-def is_registry_path(input_string: str) -> bool:
+def is_PEP_file_type(input_string: str) -> bool:
+    """
+    Determines if the provided path is actually a file type that Looper can use for loading PEP
+    """
+
+    PEP_FILE_TYPES = ["yaml", "csv"]
+
+    res = list(filter(input_string.endswith, PEP_FILE_TYPES)) != []
+    return res
+
+
+def is_pephub_registry_path(input_string: str) -> bool:
     """
     Check if input is a registry path to pephub
     :param str input_string: path to the PEP (or registry path)
     :return bool: True if input is a registry path
     """
-    try:
-        if input_string.endswith(".yaml"):
-            return False
-    except AttributeError:
-        raise RegistryPathException(
-            msg=f"Malformed registry path. Unable to parse {input_string} as a registry path."
-        )
     try:
         registry_path = RegistryPath(**parse_registry_path(input_string))
     except (ValidationError, TypeError):
@@ -767,3 +1097,45 @@ def write_submit_script(fp, content, data):
         with open(fp, "w") as f:
             f.write(content)
         return fp
+
+
+def inspect_looper_config_file(looper_config_dict) -> None:
+    """
+    Inspects looper config by printing it to terminal.
+    param dict looper_config_dict: dict representing looper_config
+
+    """
+    # Simply print this to terminal
+    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