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

looper/project.py

@@ -3,6 +3,8 @@
 import itertools
 import os
 
+from yaml import safe_load
+
 try:
     from functools import cached_property
 except ImportError:
@@ -26,6 +28,7 @@ from .exceptions import *
 from .pipeline_interface import PipelineInterface
 from .processed_project import populate_project_paths, populate_sample_paths
 from .utils import *
+from .const import PipelineLevel
 
 __all__ = ["Project"]
 
@@ -126,6 +129,12 @@ class Project(peppyProject):
 
         self[EXTRA_KEY] = {}
 
+        try:
+            # For loading PEPs via CSV, Peppy cannot infer project name.
+            name = self.name
+        except NotImplementedError:
+            self.name = None
+
         # add sample pipeline interface to the project
         if kwargs.get(SAMPLE_PL_ARG):
             self.set_sample_piface(kwargs.get(SAMPLE_PL_ARG))
@@ -144,7 +153,7 @@ class Project(peppyProject):
         self.dcc = (
             None
             if divcfg_path is None
-            else ComputingConfiguration(filepath=divcfg_path)
+            else ComputingConfiguration.from_yaml_file(filepath=divcfg_path)
         )
         if DRY_RUN_KEY in self and not self[DRY_RUN_KEY]:
             _LOGGER.debug("Ensuring project directories exist")
@@ -300,7 +309,7 @@ class Project(peppyProject):
         :return list[looper.PipelineInterface]: list of pipeline interfaces
         """
         return [
-            PipelineInterface(pi, pipeline_type="project")
+            PipelineInterface(pi, pipeline_type=PipelineLevel.PROJECT.value)
             for pi in self.project_pipeline_interface_sources
         ]
 
@@ -343,7 +352,9 @@ class Project(peppyProject):
 
         :return bool: whether pipestat configuration is complete
         """
-        return self._check_if_pipestat_configured(project_level=True)
+        return self._check_if_pipestat_configured(
+            pipeline_type=PipelineLevel.PROJECT.value
+        )
 
     def get_sample_piface(self, sample_name):
         """
@@ -441,73 +452,91 @@ class Project(peppyProject):
                 schema_set.update([schema_file])
         return list(schema_set)
 
-    def get_pipestat_managers(self, sample_name=None, project_level=False):
-        """
-        Get a collection of pipestat managers for the selected sample or project.
+    def _check_if_pipestat_configured(self, pipeline_type=PipelineLevel.SAMPLE.value):
 
-        The number of pipestat managers corresponds to the number of unique
-        output schemas in the pipeline interfaces specified by the sample or project.
+        # First check if pipestat key is in looper_config, if not return false
 
-        :param str sample_name: sample name to get pipestat managers for
-        :param bool project_level: whether the project PipestatManagers
-            should be returned
-        :return dict[str, pipestat.PipestatManager]: a mapping of pipestat
-            managers by pipeline interface name
-        """
-        pipestat_configs = self._get_pipestat_configuration(
-            sample_name=sample_name, project_level=project_level
-        )
-        return {
-            pipeline_name: PipestatManager(**pipestat_vars)
-            for pipeline_name, pipestat_vars in pipestat_configs.items()
-        }
+        if PIPESTAT_KEY not in self[EXTRA_KEY]:
+            return False
+        elif PIPESTAT_KEY in self[EXTRA_KEY]:
+            if self[EXTRA_KEY][PIPESTAT_KEY] is None:
+                return False
+            else:
+                # If pipestat key is available assume user desires pipestat usage
+                # This should return True OR raise an exception at this point.
+                return self._get_pipestat_configuration(pipeline_type)
 
-    def _check_if_pipestat_configured(self, project_level=False):
-        """
-        A helper method determining whether pipestat configuration is complete
+    def _get_pipestat_configuration(self, pipeline_type=PipelineLevel.SAMPLE.value):
 
-        :param bool project_level: whether the project pipestat config should be checked
-        :return bool: whether pipestat configuration is complete
-        """
-        try:
-            if project_level:
-                pipestat_configured = self._get_pipestat_configuration(
-                    sample_name=None, project_level=project_level
+        # First check if it already exists
+
+        if pipeline_type == PipelineLevel.SAMPLE.value:
+            for piface in self.pipeline_interfaces:
+
+                pipestat_config_path = self._check_for_existing_pipestat_config(piface)
+
+                if not pipestat_config_path:
+                    self._create_pipestat_config(piface)
+                else:
+                    piface.psm = PipestatManager(
+                        config_file=pipestat_config_path, multi_pipelines=True
+                    )
+
+        elif pipeline_type == PipelineLevel.PROJECT.value:
+            for prj_piface in self.project_pipeline_interfaces:
+                pipestat_config_path = self._check_for_existing_pipestat_config(
+                    prj_piface
                 )
-            else:
-                for s in self.samples:
-                    pipestat_configured = self._get_pipestat_configuration(
-                        sample_name=s.sample_name
+
+                if not pipestat_config_path:
+                    self._create_pipestat_config(prj_piface)
+                else:
+                    prj_piface.psm = PipestatManager(
+                        config_file=pipestat_config_path, multi_pipelines=True
                     )
-        except Exception as e:
-            context = (
-                f"Project '{self.name}'"
-                if project_level
-                else f"Sample '{s.sample_name}'"
-            )
-            _LOGGER.debug(
-                f"Pipestat configuration incomplete for {context}; "
-                f"caught exception: {getattr(e, 'message', repr(e))}"
-            )
-            return False
         else:
-            if pipestat_configured is not None and pipestat_configured != {}:
-                return True
-            else:
-                return False
+            _LOGGER.error(
+                msg="No pipeline type specified during pipestat configuration"
+            )
+
+        return True
 
-    def _get_pipestat_configuration(self, sample_name=None, project_level=False):
+    def _check_for_existing_pipestat_config(self, piface):
         """
-        Get all required pipestat configuration variables from looper_config file
+
+        config files should be in looper output directory and named as:
+
+        pipestat_config_pipelinename.yaml
+
         """
 
-        ret = {}
-        if not project_level and sample_name is None:
-            raise ValueError(
-                "Must provide the sample_name to determine the "
-                "sample to get the PipestatManagers for"
+        # Cannot do much if we cannot retrieve the pipeline_name
+        try:
+            pipeline_name = piface.data["pipeline_name"]
+        except KeyError:
+            raise Exception(
+                "To use pipestat, a pipeline_name must be set in the pipeline interface."
             )
 
+        config_file_name = f"pipestat_config_{pipeline_name}.yaml"
+        output_dir = expandpath(self.output_dir)
+
+        config_file_path = os.path.join(
+            # os.path.dirname(output_dir), config_file_name
+            output_dir,
+            config_file_name,
+        )
+
+        if os.path.exists(config_file_path):
+            return config_file_path
+        else:
+            return None
+
+    def _create_pipestat_config(self, piface):
+        """
+        Each piface needs its own config file and associated psm
+        """
+
         if PIPESTAT_KEY in self[EXTRA_KEY]:
             pipestat_config_dict = self[EXTRA_KEY][PIPESTAT_KEY]
         else:
@@ -521,13 +550,58 @@ class Project(peppyProject):
         # Expand paths in the event ENV variables were used in config files
         output_dir = expandpath(self.output_dir)
 
-        # Get looper user configured items first and update the pipestat_config_dict
+        pipestat_config_dict.update({"output_dir": output_dir})
+
+        if "output_schema" in piface.data:
+            schema_path = expandpath(piface.data["output_schema"])
+            if not os.path.isabs(schema_path):
+                # Get path relative to the pipeline_interface
+                schema_path = os.path.join(
+                    os.path.dirname(piface.pipe_iface_file), schema_path
+                )
+            pipestat_config_dict.update({"schema_path": schema_path})
+            try:
+                with open(schema_path, "r") as f:
+                    output_schema_data = safe_load(f)
+                    output_schema_pipeline_name = output_schema_data[
+                        PIPELINE_INTERFACE_PIPELINE_NAME_KEY
+                    ]
+            except Exception:
+                output_schema_pipeline_name = None
+        else:
+            output_schema_pipeline_name = None
+        if "pipeline_name" in piface.data:
+            pipeline_name = piface.data["pipeline_name"]
+            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:
+            _LOGGER.warning(
+                msg=f"Pipeline name mismatch detected. Pipeline interface: {pipeline_name}  Output schema: {output_schema_pipeline_name}  Defaulting to pipeline_interface value."
+            )
+
         try:
             results_file_path = expandpath(pipestat_config_dict["results_file_path"])
-            if not os.path.exists(os.path.dirname(results_file_path)):
-                results_file_path = os.path.join(
-                    os.path.dirname(output_dir), results_file_path
-                )
+
+            if not os.path.isabs(results_file_path):
+                # e.g. user configures "results.yaml" as results_file_path
+                if "{record_identifier}" in results_file_path:
+                    # this is specifically to check if the user wishes tro generate a file for EACH record
+                    if not os.path.exists(os.path.dirname(results_file_path)):
+                        results_file_path = os.path.join(output_dir, results_file_path)
+                else:
+                    if not os.path.exists(os.path.dirname(results_file_path)):
+                        results_file_path = os.path.join(
+                            output_dir, f"{pipeline_name}/", results_file_path
+                        )
+            else:
+                # Do nothing because the user has given an absolute file path
+                pass
+
             pipestat_config_dict.update({"results_file_path": results_file_path})
         except KeyError:
             results_file_path = None
@@ -540,57 +614,20 @@ class Project(peppyProject):
         except KeyError:
             flag_file_dir = None
 
-        if sample_name:
-            pipestat_config_dict.update({"record_identifier": sample_name})
-
-        if project_level and "project_name" in pipestat_config_dict:
-            pipestat_config_dict.update(
-                {"project_name": pipestat_config_dict["project_name"]}
-            )
-
-        if project_level and "{record_identifier}" in results_file_path:
-            # if project level and using {record_identifier}, pipestat needs some sort of record_identifier during creation
-            pipestat_config_dict.update(
-                {"record_identifier": "default_project_record_identifier"}
-            )
-
-        pipestat_config_dict.update({"output_dir": output_dir})
-
-        pifaces = (
-            self.project_pipeline_interfaces
-            if project_level
-            else self._interfaces_by_sample[sample_name]
+        # Pipestat_dict_ is now updated from all sources and can be written to a yaml.
+        pipestat_config_path = os.path.join(
+            output_dir,
+            f"pipestat_config_{pipeline_name}.yaml",
         )
 
-        for piface in pifaces:
-            # We must also obtain additional pipestat items from the pipeline author's piface
-            if "output_schema" in piface.data:
-                schema_path = expandpath(piface.data["output_schema"])
-                if not os.path.isabs(schema_path):
-                    # Get path relative to the pipeline_interface
-                    schema_path = os.path.join(
-                        os.path.dirname(piface.pipe_iface_file), schema_path
-                    )
-                pipestat_config_dict.update({"schema_path": schema_path})
-            if "pipeline_name" in piface.data:
-                pipestat_config_dict.update(
-                    {"pipeline_name": piface.data["pipeline_name"]}
-                )
-            if "pipeline_type" in piface.data:
-                pipestat_config_dict.update(
-                    {"pipeline_type": piface.data["pipeline_type"]}
-                )
+        # Two end goals, create a config file
+        write_pipestat_config(pipestat_config_path, pipestat_config_dict)
 
-            # Pipestat_dict_ is now updated from all sources and can be written to a yaml.
-            looper_pipestat_config_path = os.path.join(
-                os.path.dirname(output_dir), "looper_pipestat_config.yaml"
-            )
-            write_pipestat_config(looper_pipestat_config_path, pipestat_config_dict)
+        piface.psm = PipestatManager(
+            config_file=pipestat_config_path, multi_pipelines=True
+        )
 
-            ret[piface.pipeline_name] = {
-                "config_file": looper_pipestat_config_path,
-            }
-        return ret
+        return None
 
     def populate_pipeline_outputs(self):
         """
@@ -657,7 +694,7 @@ class Project(peppyProject):
         pifaces_by_sample = {}
         for source, sample_names in self._samples_by_interface.items():
             try:
-                pi = PipelineInterface(source, pipeline_type="sample")
+                pi = PipelineInterface(source, pipeline_type=PipelineLevel.SAMPLE.value)
             except PipelineInterfaceConfigError as e:
                 _LOGGER.debug(f"Skipping pipeline interface creation: {e}")
             else:
@@ -708,7 +745,9 @@ class Project(peppyProject):
                 for source in piface_srcs:
                     source = self._resolve_path_with_cfg(source)
                     try:
-                        PipelineInterface(source, pipeline_type="sample")
+                        PipelineInterface(
+                            source, pipeline_type=PipelineLevel.SAMPLE.value
+                        )
                     except (
                         ValidationError,
                         IOError,

looper/utils.py

@@ -16,9 +16,10 @@ from peppy import Project as peppyProject
 from peppy.const import *
 from ubiquerg import convert_value, expandpath, parse_registry_path
 from pephubclient.constants import RegistryPath
-from pydantic.error_wrappers import ValidationError
+from pydantic import ValidationError
 
 from .const import *
+from .command_models.commands import SUPPORTED_COMMANDS
 from .exceptions import MisconfigurationException, RegistryPathException
 
 _LOGGER = getLogger(__name__)
@@ -94,7 +95,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,19 +253,20 @@ 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):
     """
     Read in a looper dotfile and set arguments.
 
     Priority order: CLI > dotfile/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
         with defaults suppressed
     :return argparse.Namespace: selected argument values
     """
     cfg_args_all = (
-        _get_subcommand_args(parser_args)
+        _get_subcommand_args(subcommand_name, parser_args)
         if os.path.exists(parser_args.config_file)
         else dict()
     )
@@ -273,23 +277,42 @@ 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]]
+    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]]
                 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.
@@ -321,8 +344,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:
@@ -449,7 +472,7 @@ def initiate_looper_config(
         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)
@@ -537,12 +560,25 @@ 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 +611,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 +807,15 @@ 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}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: looper
-Version: 1.7.1
+Version: 1.8.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
@@ -21,13 +21,14 @@ Requires-Dist: eido >=0.2.1
 Requires-Dist: jinja2
 Requires-Dist: logmuse >=0.2.0
 Requires-Dist: pandas >=2.0.2
-Requires-Dist: pephubclient >=0.1.2
-Requires-Dist: peppy >=0.40.0
-Requires-Dist: pipestat <0.9.0,>=0.8.0
+Requires-Dist: pephubclient >=0.4.0
+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: yacman >=0.9.2
+Requires-Dist: yacman ==0.9.3
+Requires-Dist: pydantic2-argparse >=0.9.2
 
 # <img src="docs/img/looper_logo.svg" alt="looper logo" height="70">
 

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

@@ -1,19 +1,24 @@
 looper/__init__.py,sha256=f_z9YY4ibOk7eyWoaViH_VaCXMlPQeiftbnibSFj-3E,1333
-looper/__main__.py,sha256=8CX2ae8mUQNI_Z8pdBT4i5UFqROFX1awyFnuYCKuYXg,238
-looper/_version.py,sha256=rHqoOqa3LxWXvrBmnnm2LDmV9IlmMEb5qOmw5doj3fk,22
+looper/__main__.py,sha256=OOCmI-dPUvInnJHkHNMf54cblNJ3Yl9ELOwZcfOXmD8,240
+looper/_version.py,sha256=Oc_xF94AMAHKZkZlB5rBt1iO0TXWFalg65MP4T2qt-A,22
 looper/cli_divvy.py,sha256=J07x83sqC4jJeu3_yS6KOARPWmwKGAV7JvN33T5zDac,5907
-looper/cli_looper.py,sha256=se-EbQ4nucWxMiU0VLnmV0Kss-JMjSmWih6vHaOiLi0,26367
-looper/conductor.py,sha256=9k0r_vsHCP25MrDjz7GR16_EEdqP9JZELYZJVm6ny1g,30777
-looper/const.py,sha256=bPj4lTuj2l6gwHROWqj16iHfJFo9ghZAz8THNREWW4U,8558
-looper/divvy.py,sha256=qa1ebbQTfNupAyDfhfEJ6mbZ_V3zk-D_E-Tck7miJ38,15688
+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/exceptions.py,sha256=r6SKKt-m8CXQnXGDnuiwoA6zBJhIZflygBKjX4RCloI,3419
-looper/looper.py,sha256=U3mNqXRDZRzmFXV26TcPQYKPdY1plPvMraNHTnps4mQ,30448
+looper/looper.py,sha256=XomJIis4sFHOO5qEwzmyKT85X-lKNURX8yhOftTFmbY,30099
 looper/parser_types.py,sha256=d3FHt54f9jo9VZMr5SQkbghcAdABqiYZW2JBGO5EBnw,2327
 looper/pipeline_interface.py,sha256=y46tB1_73d1FX8N1w4-GGvRBJ7rqhenuUYVtUfIhK5s,14974
 looper/plugins.py,sha256=MaMdPmK9U_4FkNJE5kccohBbY1i2qj1NTEucubFOJek,5747
 looper/processed_project.py,sha256=jZxoMYafvr-OHFxylc5ivGty1VwXBZhl0kgoFkY-174,9837
-looper/project.py,sha256=nkNP7ftVs82Tnk2Yn6FUp60_D6bjE9sSvySE0SHqsmg,36171
-looper/utils.py,sha256=i7srIXPEnQjtNaoP0ziRpdYfB7HNY5_3rW5LoKIM15I,27257
+looper/project.py,sha256=vgJVk_H7DahMrmcGyKv8tcb6rR1JTk2RcRRO1JV866E,37290
+looper/utils.py,sha256=TS7w46XwYzb6g3mA26xOUwDAuwBnJz3IHgAJRGHZaH8,29483
+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/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
@@ -55,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.7.1.dist-info/LICENSE.txt,sha256=oB6ZGDa4kcznznJKJsLLFFcOZyi8Y6e2Jv0rJozgp-I,1269
-looper-1.7.1.dist-info/METADATA,sha256=RRHlAK9WkJv1b9KtkZpMXHk2xyATbe5DJWCcRZMq7Wk,1740
-looper-1.7.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-looper-1.7.1.dist-info/entry_points.txt,sha256=AEL1eb0gPLYvAEUewM35Ng4scXGZIWJK4Mxdj3Hm8Fw,83
-looper-1.7.1.dist-info/top_level.txt,sha256=I0Yf7djsoQAMzwHBbDiQi9hGtq4Z41_Ma5CX8qXG8Y8,7
-looper-1.7.1.dist-info/RECORD,,
+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.7.1.dist-info → looper-1.8.0.dist-info}/entry_points.txt

@@ -1,3 +1,3 @@
 [console_scripts]
 divvy = looper.__main__:divvy_main
-looper = looper.__main__:main
+looper = looper.cli_pydantic:main