sierra-research 1.3.6__py3-none-any.whl → 1.5.0__py3-none-any.whl

sierra/core/models/interface.py

@@ -1,10 +1,11 @@
 # Copyright 2020 John Harwell, All rights reserved.
 #
 #  SPDX-License-Identifier: MIT
-"""Interface classes for the mathematical models framework in SIERRA.
-
-Models can be run and added to any configured graph during stage 4.
+"""
+Interface classes for the mathematical models framework in SIERRA.
 
+Models can be run during stage 3 and added to any configured graph during stage
+4.
 """
 
 # Core packages
@@ -16,25 +17,32 @@ import implements
 
 # Project packages
 from sierra.core.variables import batch_criteria as bc
-from sierra.core import types
+from sierra.core import types, exproot, batchroot
 
 
-class IConcreteIntraExpModel1D(implements.Interface):
+class IIntraExpModel1D(implements.Interface):
     """Interface for one-dimensional models.
 
     1D models are those that generate a single time series from zero or more
-    experimental outputs within a *single* :term:`Experiment`. Models will be
-    rendered as lines on a
-    :class:`~sierra.core.graphs.stacked_line_graph.StackedLineGraph`. Models
-    "target" one or more CSV files which are already configured to be generated,
+    experimental outputs within a *single* :term:`Experiment`.  Models will be
+    rendered as lines on a :func:`~sierra.core.graphs.stacked_line`.  Models
+    "target" one or more graphs which are already configured to be generated,
     and will show up as additional lines on the generated graph.
 
+    The dataframes generated by models implement this interface MUST have
+    indices of the same length as those in the graphs they target.
     """
 
-    def run(self,
-            criteria: bc.IConcreteBatchCriteria,
-            exp_num: int,
-            cmdopts: types.Cmdopts) -> tp.List[pd.DataFrame]:
+    def __init__(self, params: types.YAMLDict) -> None:
+        pass
+
+    def run(
+        self,
+        criteria: bc.XVarBatchCriteria,
+        exp_num: int,
+        cmdopts: types.Cmdopts,
+        pathset: exproot.PathSet,
+    ) -> tp.List[pd.DataFrame]:
         """Run the model and generate a list of dataframes.
 
         Each dataframe can (potentially) target different graphs. All dataframes
@@ -46,10 +54,9 @@ class IConcreteIntraExpModel1D(implements.Interface):
         """
         raise NotImplementedError
 
-    def run_for_exp(self,
-                    criteria: bc.IConcreteBatchCriteria,
-                    cmdopts: types.Cmdopts,
-                    exp_num: int) -> bool:
+    def should_run(
+        self, criteria: bc.XVarBatchCriteria, cmdopts: types.Cmdopts, exp_num: int
+    ) -> bool:
         """
         Determine if the model should be run for the specified experiment.
 
@@ -59,23 +66,6 @@ class IConcreteIntraExpModel1D(implements.Interface):
         """
         raise NotImplementedError
 
-    def target_csv_stems(self) -> tp.List[str]:
-        """Return a list of CSV file stems that the model is targeting.
-
-         File stem = path sans directory path and extension.
-        """
-        raise NotImplementedError
-
-    def legend_names(self) -> tp.List[str]:
-        """Compute names for the model predictions for the target graph legend.
-
-        Applicable to:
-
-        - :class:`~sierra.core.graphs.stacked_line_graph.StackedLineGraph`
-
-        """
-        raise NotImplementedError
-
     def __repr__(self) -> str:
         """
         Return the UUID string of the model name.
@@ -83,86 +73,42 @@ class IConcreteIntraExpModel1D(implements.Interface):
         raise NotImplementedError
 
 
-class IConcreteIntraExpModel2D(implements.Interface):
-    """Interface for two-dimensional models.
-
-    2D models are those that generate a list of 2D matrices, forming a 2D time
-    series. Can be built from zero or more experimental outputs from a *single*
-    :term:`Experiment`. Models "target" one or more CSV files which are already
-    configured to be generated, and will show up as additional lines on the
-    generated graph.
+class IInterExpModel1D(implements.Interface):
+    """Interface for one-dimensional models.
 
+    1D models are those that generate a single time series from any number of
+    experimental outputs across *all* experiments in a batch (or from another
+    source).  Models will be rendered as lines on a
+    :func:`~sierra.core.graphs.summary_line`.  Models "target" one or more
+    :term:`Collated Output Data` files which are already configured to be
+    generated, and will show up as additional lines on the generated graph.
     """
 
-    def run(self,
-            criteria: bc.IConcreteBatchCriteria,
-            exp_num: int,
-            cmdopts: types.Cmdopts) -> tp.List[pd.DataFrame]:
-        """Run the model and generate a list of dataframes.
-
-        Each dataframe can (potentially) target a different graph. Each
-        dataframe should be a NxM grid (with N not necessarily equal to M). All
-        dataframes do not have to be the same dimensions. The index of a given
-        dataframe in a list should correspond to the model value for
-        interval/timestep.
-
-        """
-        raise NotImplementedError
-
-    def run_for_exp(self,
-                    criteria: bc.IConcreteBatchCriteria,
-                    cmdopts: types.Cmdopts,
-                    exp_num: int) -> bool:
-        """Determine if a model should be run for the specified experiment.
-
-        Some models may only be valid/make sense to run for a subset of
-        experiments within a batch, so models can be selectively executed with
-        this function.
-
-        """
-        raise NotImplementedError
-
-    def target_csv_stems(self) -> tp.List[str]:
-        """Return a list of CSV file stems that the model is targeting.
-
-         File stem = path sans directory path and extension.
-        """
-        raise NotImplementedError
-
-    def __repr__(self) -> str:
-        """
-        Return the UUID string of the model name.
-        """
-        raise NotImplementedError
-
+    def __init__(self, params: types.YAMLDict) -> None:
+        pass
 
-class IConcreteInterExpModel1D(implements.Interface):
-    """Interface for one-dimensional models.
+    def run(
+        self,
+        criteria: bc.XVarBatchCriteria,
+        cmdopts: types.Cmdopts,
+        pathset: batchroot.PathSet,
+    ) -> tp.List[pd.DataFrame]:
+        """Run the model and generate list of dataframes.
 
-    1D models are those that generate a single time series from any number of
-    experimental outputs across *all* experiments in a batch(or from another
-    source). Models will be rendered as lines on a
-    :class:`~sierra.core.graphs.summary_line_graph.SummaryLineGraph`.  Models
-    "target" one or more CSV files which are already configured to be generated,
-    and will show up as additional lines on the generated graph.
+        Each returned dataframe must have:
 
-    """
+        - The index named ``Experiment ID``
 
-    def run(self,
-            criteria: bc.IConcreteBatchCriteria,
-            cmdopts: types.Cmdopts) -> tp.List[pd.DataFrame]:
-        """Run the model and generate list of dataframes.
+        - Indices which correspond to ``criteria.gen_exp_names()``
 
-        Each dataframe can (potentially) target a different graph. Each
-        dataframe should contain a single row, with one column for the predicted
-        value of the model for each experiment in the batch.
+        Each dataframe can (potentially) target a different graph.
 
         """
         raise NotImplementedError
 
-    def run_for_batch(self,
-                      criteria: bc.IConcreteBatchCriteria,
-                      cmdopts: types.Cmdopts) -> bool:
+    def should_run(
+        self, criteria: bc.XVarBatchCriteria, cmdopts: types.Cmdopts
+    ) -> bool:
         """
         Determine if the model should be run for the specified batch criteria.
 
@@ -171,23 +117,6 @@ class IConcreteInterExpModel1D(implements.Interface):
         """
         raise NotImplementedError
 
-    def target_csv_stems(self) -> tp.List[str]:
-        """Return a list of CSV file stems that the model is targeting.
-
-         File stem = path sans directory path and extension.
-        """
-        raise NotImplementedError
-
-    def legend_names(self) -> tp.List[str]:
-        """Compute names for the model predictions for the target graph legend.
-
-        Applicable to:
-
-        - ~sierra.core.graphs.summary_line_graph.SummaryLineGraph`
-
-        """
-        raise NotImplementedError
-
     def __repr__(self) -> str:
         """
         Return the UUID string of the model name.
@@ -195,6 +124,7 @@ class IConcreteInterExpModel1D(implements.Interface):
         raise NotImplementedError
 
 
-__api__ = ['IConcreteIntraExpModel1D',
-           'IConcreteIntraExpModel2D',
-           'IConcreteInterExpModel1D']
+__all__ = [
+    "IIntraExpModel1D",
+    "IInterExpModel1D",
+]

sierra/core/pipeline/__init__.py

@@ -1,8 +1,5 @@
 # Copyright 2022 John Harwell, All rights reserved.
 #
 #  SPDX-License-Identifier: MIT
-# import sierra.core.pipeline.stage1
-# import sierra.core.pipeline.stage2
-# import sierra.core.pipeline.stage3
-# import sierra.core.pipeline.stage4
-# import sierra.core.pipeline.stage5
+
+"""Container module for main pipeline."""

sierra/core/pipeline/pipeline.py

@@ -3,7 +3,7 @@
 #  SPDX-License-Identifier: MIT
 """The 5 pipeline stages implemented by SIERRA.
 
-See :ref:`ln-sierra-usage-pipeline` for high-level documentation.
+See :ref:`usage/pipeline` for high-level documentation.
 
 """
 
@@ -12,13 +12,14 @@ import typing as tp
 import logging
 import argparse
 import pathlib
+import os
 
 # 3rd party packages
 import yaml
 
 # Project packages
-import sierra.core.plugin_manager as pm
-from sierra.core import types, config, utils
+import sierra.core.plugin as pm
+from sierra.core import config, utils, batchroot, types
 
 from sierra.core.pipeline.stage1.pipeline_stage1 import PipelineStage1
 from sierra.core.pipeline.stage2.pipeline_stage2 import PipelineStage2
@@ -30,110 +31,54 @@ from sierra.core.pipeline.stage5.pipeline_stage5 import PipelineStage5
 class Pipeline:
     "Implements SIERRA's 5 stage pipeline."
 
-    def __init__(self,
-                 args: argparse.Namespace,
-                 controller: tp.Optional[str],
-                 rdg_opts: types.Cmdopts) -> None:
-        self.args = args
+    def __init__(
+        self,
+        args: argparse.Namespace,
+        controller: tp.Optional[str],
+        pathset: tp.Optional[batchroot.PathSet] = None,
+    ) -> None:
         self.logger = logging.getLogger(__name__)
+        self.pathset = pathset
 
-        assert all(stage in [1, 2, 3, 4, 5] for stage in args.pipeline), \
-            f"Invalid pipeline stage in {args.pipeline}: Only 1-5 valid"
-
-        self.cmdopts = {
-            # multistage
-            'pipeline': self.args.pipeline,
-            'sierra_root': self.args.sierra_root,
-            'scenario': self.args.scenario,
-            'template_input_file': self.args.template_input_file,
-            'project': self.args.project,
-            'exec_env': args.exec_env,
-            'platform_vc': self.args.platform_vc,
-            "n_runs": args.n_runs,
-            'project_imagizing': self.args.project_imagizing,
-            'exp_overwrite': self.args.exp_overwrite,
-            'exp_range': self.args.exp_range,
-            'dist_stats': self.args.dist_stats,
-            'skip_collate': self.args.skip_collate,
-            'platform': self.args.platform,
-            'processing_serial': self.args.processing_serial,
-
-            'plot_log_xscale': self.args.plot_log_xscale,
-            'plot_enumerated_xscale': self.args.plot_enumerated_xscale,
-            'plot_log_yscale': self.args.plot_log_yscale,
-            'plot_regression_lines': self.args.plot_regression_lines,
-            'plot_primary_axis': self.args.plot_primary_axis,
-            'plot_large_text': self.args.plot_large_text,
-            'plot_transpose_graphs': self.args.plot_transpose_graphs,
-
-            # stage 1
-            'preserve_seeds': self.args.preserve_seeds,
-
-            # stage 2
-            'nodefile': self.args.nodefile,
-
-            # stage 3
-            'df_skip_verify': self.args.df_skip_verify,
-            'df_homogenize': self.args.df_homogenize,
-            'render_cmd_opts': self.args.render_cmd_opts,
-            'processing_mem_limit': self.args.processing_mem_limit,
-            'storage_medium': self.args.storage_medium,
-
-            # stage 4
-            'exp_graphs': self.args.exp_graphs,
-
-            'project_no_LN': self.args.project_no_LN,
-            'project_no_HM': self.args.project_no_HM,
-            'project_rendering': self.args.project_rendering,
-            'bc_rendering': self.args.bc_rendering,
-
-            'models_enable': self.args.models_enable,
-
-            # stage 5
-            'controllers_list': self.args.controllers_list,
-            'controllers_legend': self.args.controllers_legend,
-            'scenarios_list': self.args.scenarios_list,
-            'scenarios_legend': self.args.scenarios_legend,
-            'scenario_comparison': self.args.scenario_comparison,
-            'controller_comparison': self.args.controller_comparison,
-            'comparison_type': self.args.comparison_type,
-        }
-
-        # Load additional cmdline options from platform
-        self.logger.debug("Updating cmdopts with extensions from '%s'",
-                          self.cmdopts['platform'])
-        module = pm.module_load_tiered("cmdline",
-                                       platform=self.cmdopts['platform'])
-        module.PlatformCmdline.cmdopts_update(self.args, self.cmdopts)
-
-        if rdg_opts is not None:
-            self.cmdopts.update(rdg_opts)
-
-            # Load additional cmdline options from project. This is mandatory,
-            # because all projects have to define --controller and --scenario
-            # at a minimum.
-            self.logger.debug("Updating cmdopts with extensions from '%s'",
-                              self.cmdopts['project'])
-            path = "{0}.cmdline".format(self.cmdopts['project'])
-            module = pm.module_load(path)
-
-            module.Cmdline.cmdopts_update(self.args, self.cmdopts)
+        self.logger.info("Computed run-time tree:\n%s", self.pathset)
 
-        project = pm.pipeline.get_plugin(self.cmdopts['project'])
-        path = project['parent_dir'] / self.cmdopts['project']
+        assert all(
+            stage in [1, 2, 3, 4, 5] for stage in args.pipeline
+        ), f"Invalid pipeline stage in {args.pipeline}: Only 1-5 valid"
 
-        self.cmdopts['project_root'] = str(path)
-        self.cmdopts['project_config_root'] = str(path / 'config')
-        self.cmdopts['project_model_root'] = str(path / 'models')
+        # The namespace passed in contains arguments for the core and all
+        # plugins, so its OK to handle shortforms which aren't in the SIERRA
+        # core at this point. This also preserves the "longforms trump
+        # shortforms if both are passed" policy because their converted
+        # shortforms are overwritten below.
+        self.args = args
+        shortforms = self._handle_shortforms()
+
+        # Check for problematic characters in arguments used to create directory
+        # paths.
+        if any(
+            "+" in arg
+            for arg in [
+                self.args.scenario or [],
+                self.args.controller or [],
+                self.args.batch_criteria,
+            ]
+        ):
+            raise RuntimeError(
+                "{--scenario, --controller, --batch-criteria} cannot contain '+'."
+            )
+
+        self.cmdopts = self._init_cmdopts(shortforms)
 
         self._load_config()
 
         if 5 not in self.args.pipeline:
-            bc = pm.module_load_tiered(project=self.cmdopts['project'],
-                                       path='variables.batch_criteria')
-            self.batch_criteria = bc.factory(self.main_config,
-                                             self.cmdopts,
-                                             self.args)
+            bc = pm.module_load_tiered(
+                project=self.cmdopts["project"], path="variables.batch_criteria"
+            )
+            self.batch_criteria = bc.factory(
+                self.main_config, self.cmdopts, self.pathset.input_root, self.args
+            )
 
         self.controller = controller
 
@@ -142,32 +87,201 @@ class Pipeline:
         Run pipeline stages 1-5 as configured.
         """
         if 1 in self.args.pipeline:
-            PipelineStage1(self.cmdopts,
-                           self.controller,  # type: ignore
-                           self.batch_criteria).run()
+            PipelineStage1(
+                self.cmdopts,
+                self.pathset,
+                self.controller,  # type: ignore
+                self.batch_criteria,
+            ).run()
 
         if 2 in self.args.pipeline:
-            PipelineStage2(self.cmdopts).run(self.batch_criteria)
+            PipelineStage2(self.cmdopts, self.pathset).run(self.batch_criteria)
 
         if 3 in self.args.pipeline:
-            PipelineStage3(self.main_config,
-                           self.cmdopts).run(self.batch_criteria)
+            PipelineStage3(self.main_config, self.cmdopts, self.pathset).run(
+                self.batch_criteria
+            )
 
         if 4 in self.args.pipeline:
-            PipelineStage4(self.main_config,
-                           self.cmdopts).run(self.batch_criteria)
+            PipelineStage4(self.main_config, self.cmdopts, self.pathset).run(
+                self.batch_criteria
+            )
 
         # not part of default pipeline
         if 5 in self.args.pipeline:
-            PipelineStage5(self.main_config,
-                           self.cmdopts).run(self.args)
+            PipelineStage5(self.main_config, self.cmdopts).run(self.args)
+
+    def _init_cmdopts(self, shortforms: types.Cmdopts) -> types.Cmdopts:
+        longforms = {
+            # multistage
+            "pipeline": self.args.pipeline,
+            "sierra_root": os.path.expanduser(self.args.sierra_root),
+            "scenario": self.args.scenario,
+            "expdef_template": self.args.expdef_template,
+            "project": self.args.project,
+            "execenv": self.args.execenv,
+            "engine_vc": self.args.engine_vc,
+            "n_runs": self.args.n_runs,
+            "exp_overwrite": self.args.exp_overwrite,
+            "exp_range": self.args.exp_range,
+            "engine": self.args.engine,
+            "processing_parallelism": self.args.processing_parallelism,
+            "exec_parallelism_paradigm": self.args.exec_parallelism_paradigm,
+            "expdef": self.args.expdef,
+            # stage 1
+            "preserve_seeds": self.args.preserve_seeds,
+            # stage 2
+            "nodefile": self.args.nodefile,
+            # stage 3
+            "proc": self.args.proc,
+            "df_verify": self.args.df_verify,
+            "df_homogenize": self.args.df_homogenize,
+            "processing_mem_limit": self.args.processing_mem_limit,
+            "storage": self.args.storage,
+            # stage 4
+            "prod": self.args.prod,
+            # stage 5
+            "compare": self.args.compare,
+        }
+        cmdopts = longforms
+
+        # Load additional cmdline options from --engine
+        self.logger.debug("Updating cmdopts from --engine=%s", cmdopts["engine"])
+        module = pm.module_load_tiered("cmdline", engine=cmdopts["engine"])
+        cmdopts |= module.to_cmdopts(self.args)
+
+        # Load additional cmdline options from --execenv
+        path = "{0}.cmdline".format(cmdopts["execenv"])
+        if pm.module_exists(path):
+            self.logger.debug("Updating cmdopts from --execenv=%s", cmdopts["execenv"])
+            module = pm.module_load_tiered(path)
+            cmdopts |= module.to_cmdopts(self.args)
+
+        # Load additional cmdline options from --expdef
+        path = "{0}.cmdline".format(cmdopts["expdef"])
+        if pm.module_exists(path):
+            self.logger.debug("Updating cmdopts from --expdef=%s", cmdopts["expdef"])
+            module = pm.module_load_tiered(path)
+            cmdopts |= module.to_cmdopts(self.args)
+
+        # Load additional cmdline options from --proc plugins
+        for p in cmdopts["proc"]:
+            path = "{0}.cmdline".format(p)
+            if pm.module_exists(path):
+                self.logger.debug("Updating cmdopts from --proc=%s", p)
+                module = pm.module_load_tiered(path)
+                cmdopts |= module.to_cmdopts(self.args)
+
+        for p in cmdopts["prod"]:
+            path = "{0}.cmdline".format(p)
+            if pm.module_exists(path):
+                self.logger.debug("Updating cmdopts from --prod=%s", p)
+                module = pm.module_load_tiered(path)
+                cmdopts |= module.to_cmdopts(self.args)
+
+        for p in cmdopts["compare"]:
+            path = "{0}.cmdline".format(p)
+            if pm.module_exists(path):
+                self.logger.debug("Updating cmdopts from --compare=%s", p)
+                module = pm.module_load_tiered(path)
+                cmdopts |= module.to_cmdopts(self.args)
+
+        # Load additional cmdline options from --storage
+        path = "{0}.cmdline".format(cmdopts["storage"])
+        if pm.module_exists(path):
+            self.logger.debug("Updating cmdopts from --storage=%s", cmdopts["storage"])
+            module = pm.module_load_tiered(path)
+            cmdopts |= module.to_cmdopts(self.args)
+
+        # Load additional cmdline options from project. This is mandatory,
+        # because all projects have to define --controller and --scenario
+        # at a minimum.
+        self.logger.debug("Updating cmdopts from --project=%s", cmdopts["project"])
+        path = "{0}.cmdline".format(cmdopts["project"])
+        module = pm.module_load(path)
+        cmdopts |= module.to_cmdopts(self.args)
+
+        # This has to be AFTER loading cmdopts from all plugins so that any
+        # unset/defaulted options don't override the shortform. This also means
+        # that shortforms override longforms if both are passed.
+        cmdopts |= shortforms
+
+        # Projects are specified as X.Y on cmdline so to get the path to the
+        # project dir we combine the parent_dir (which is already a path) and
+        # the name of the project (Y component).
+        project = pm.pipeline.get_plugin(cmdopts["project"])
+        path = project["parent_dir"] / "/".join(cmdopts["project"].split("."))
+        cmdopts["project_root"] = str(path)
+        cmdopts["project_config_root"] = str(path / "config")
+        cmdopts["project_model_root"] = str(path / "models")
+
+        return cmdopts
+
+    def _handle_shortforms(self) -> types.Cmdopts:
+        """
+        Replace all shortform arguments in with their longform counterparts.
+
+        SIERRA always references arguments internally via longform if needed, so
+        this is required.
+
+        """
+
+        shortform_map = {
+            "p": "plot",
+            "e": "exp",
+            "x": "exec",
+            "s": "skip",
+        }
+        ret = {}
+
+        for k in shortform_map:
+            passed = getattr(self.args, k, None)
+            if not passed:
+                self.logger.trace(
+                    ("No shortform args for -%s -> --%s passed to SIERRA"),
+                    k,
+                    shortform_map[k],
+                )
+                continue
+
+            self.logger.trace(
+                "Collected shortform args for -%s -> --%s: %s",
+                k,
+                shortform_map[k],
+                passed,
+            )
+
+            # There are 3 ways to pass shortform arguments, assuming a shortform
+            # of 'X:
+            #
+            # 1. -Xarg
+            # 2. -Xarg=foo
+            # 3. -Xarg foo
+            for p in passed:
+                if len(p) == 1 and "=" not in p[0]:  # boolean
+                    # Boolean shortfrom flags should store False if they contain
+                    # "no", as a user would expect.
+                    key = "{0}_{1}".format(
+                        shortform_map[k], p[0].replace("-", "_").replace("no_", "")
+                    )
+                    ret[key] = "no" not in p[0]
+
+                elif len(p) == 1 and "=" in p[0]:
+                    arg, value = p[0].split("=")
+                    key = "{0}_{1}".format(shortform_map[k], arg.replace("-", "_"))
+                    ret[key] = value
+                else:
+                    key = "{0}_{1}".format(shortform_map[k], p[1:].replace("-", "_"))
+                    ret[key] = p[1:]
+
+        return ret
 
     def _load_config(self) -> None:
-        self.logger.debug("Loading project config from '%s'",
-                          self.cmdopts['project_config_root'])
+        self.logger.debug(
+            "Loading project config from '%s'", self.cmdopts["project_config_root"]
+        )
 
-        main_path = pathlib.Path(self.cmdopts['project_config_root'],
-                                 config.kYAML.main)
+        main_path = pathlib.Path(self.cmdopts["project_config_root"], config.kYAML.main)
         try:
             with utils.utf8open(main_path) as f:
                 self.main_config = yaml.load(f, yaml.FullLoader)
@@ -176,17 +290,5 @@ class Pipeline:
             self.logger.fatal("%s must exist!", main_path)
             raise
 
-        perf_path = pathlib.Path(self.cmdopts['project_config_root'],
-                                 self.main_config['sierra']['perf'])
-        try:
-            perf_config = yaml.load(utils.utf8open(perf_path), yaml.FullLoader)
-
-        except FileNotFoundError:
-            self.logger.warning("%s does not exist!", perf_path)
-            perf_config = {}
-        self.main_config['sierra'].update(perf_config)
-
 
-__api__ = [
-    'Pipeline'
-]
+__all__ = ["Pipeline"]

sierra/core/pipeline/stage1/__init__.py

@@ -0,0 +1,10 @@
+# Copyright 2021 John Harwell, All rights reserved.
+#
+#  SPDX-License-Identifier: MIT
+"""Container module for things stage 1 of the pipeline."""
+
+# Core packages
+
+# 3rd party packages
+
+# Project packages