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

sierra/plugins/platform/ros1gazebo/generators/platform_generators.py

@@ -1,137 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-"""Classes for generating common XML modifications for :term:`ROS1+Gazebo`.
-
-I.e., changes which are platform-specific, but applicable to all projects using
-the platform.
-
-"""
-# Core packages
-import logging
-
-# 3rd party packages
-
-# Project packages
-from sierra.core.experiment import spec, definition
-from sierra.core import types, ros1, config
-
-
-class PlatformExpDefGenerator(ros1.generators.ROSExpDefGenerator):
-    """
-    Init the object.
-
-    Attributes:
-
-        controller: The controller used for the experiment.
-
-        cmdopts: Dictionary of parsed cmdline parameters.
-    """
-
-    def __init__(self,
-                 exp_spec: spec.ExperimentSpec,
-                 controller: str,
-                 cmdopts: types.Cmdopts,
-                 **kwargs) -> None:
-        super().__init__(exp_spec, controller, cmdopts, **kwargs)
-        self.logger = logging.getLogger(__name__)
-
-    def generate(self) -> definition.XMLExpDef:
-        exp_def = super().generate()
-
-        exp_def.write_config.add({
-            'src_parent': ".",
-            'src_tag': "master",
-            'opath_leaf': "_master" + config.kROS['launch_file_ext'],
-            'create_tags': None,
-            'dest_parent': None,
-            'rename_to': 'launch'
-        })
-
-        exp_def.write_config.add({
-            'src_parent': ".",
-            'src_tag': "robot",
-            'opath_leaf': "_robots" + config.kROS['launch_file_ext'],
-            'create_tags': None,
-            'dest_parent': None,
-            'rename_to': 'launch'
-        })
-
-        # Setup gazebo experiment
-        self._generate_gazebo_core(exp_def)
-
-        # Setup gazebo visualization
-        self._generate_gazebo_vis(exp_def)
-
-        return exp_def
-
-    def _generate_gazebo_core(self, exp_def: definition.XMLExpDef) -> None:
-        """
-        Generate XML tag changes to setup Gazebo core experiment parameters.
-
-        Does not write generated changes to the run definition pickle
-        file.
-        """
-        self.logger.debug("Generating Gazebo experiment changes (all runs)")
-
-        # Start Gazebo/ROS in debug mode to make post-mortem analysis easier.
-        exp_def.tag_add("./master/include",
-                        "arg",
-                        {
-                            "name": "verbose",
-                            "value": "true"
-                        })
-
-        # Terminate Gazebo server whenever the launch script that invoked it
-        # exits.
-        exp_def.tag_add("./master/include",
-                        "arg",
-                        {
-                            "name": "server_required",
-                            "value": "true"
-                        })
-
-        # Don't record stuff
-        exp_def.tag_remove("./master/include", "arg/[@name='headless']")
-        exp_def.tag_remove("./master/include", "arg/[@name='recording']")
-
-        # Don't start paused
-        exp_def.tag_remove("./master/include", "arg/[@name='paused']")
-
-        # Don't start gazebo under gdb
-        exp_def.tag_remove("./master/include", "arg/[@name='debug']")
-
-    def _generate_gazebo_vis(self, exp_def: definition.XMLExpDef) -> None:
-        """
-        Generate XML changes to configure Gazebo visualizations.
-
-        Does not write generated changes to the simulation definition pickle
-        file.
-        """
-        exp_def.tag_remove_all("./master/include", "arg/[@name='gui']")
-        exp_def.tag_add("./master/include",
-                        "arg",
-                        {
-                            "name": "gui",
-                            "value": "false"
-                        })
-
-
-class PlatformExpRunDefUniqueGenerator(ros1.generators.ROSExpRunDefUniqueGenerator):
-    def __init__(self,
-                 *args,
-                 **kwargs) -> None:
-        ros1.generators.ROSExpRunDefUniqueGenerator.__init__(
-            self, *args, **kwargs)
-
-    def generate(self, exp_def: definition.XMLExpDef):
-        exp_def = super().generate(exp_def)
-
-        self.generate_random(exp_def)
-        self.generate_paramfile(exp_def)
-
-
-__api__ = [
-    'PlatformExpDefGenerator',
-    'PlatformExpRunDefUniqueGenerator'
-]

sierra/plugins/platform/ros1gazebo/plugin.py

@@ -1,335 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-"""
-Provides platform-specific callbacks for the :term:`ROS1+Gazebo` platform.
-"""
-# Core packages
-import argparse
-import logging
-import os
-import re
-import typing as tp
-import sys
-import pathlib
-import psutil
-
-# 3rd party packages
-import packaging.version
-import implements
-
-# Project packages
-from sierra.plugins.platform.ros1gazebo import cmdline
-from sierra.core import hpc, platform, config, ros1, types
-from sierra.core.experiment import bindings, definition, xml
-import sierra.core.variables.batch_criteria as bc
-
-
-class CmdlineParserGenerator():
-    def __call__(self) -> argparse.ArgumentParser:
-        parent1 = hpc.cmdline.HPCCmdline([-1, 1, 2, 3, 4, 5]).parser
-        parent2 = ros1.cmdline.ROSCmdline([-1, 1, 2, 3, 4, 5]).parser
-        return cmdline.PlatformCmdline(parents=[parent1, parent2],
-                                       stages=[-1, 1, 2, 3, 4, 5]).parser
-
-
-@implements.implements(bindings.IParsedCmdlineConfigurer)
-class ParsedCmdlineConfigurer():
-    def __init__(self, exec_env: str) -> None:
-        self.exec_env = exec_env
-        self.logger = logging.getLogger('ros1gazebo.plugin')
-
-    def __call__(self, args: argparse.Namespace) -> None:
-        # No configuration needed for stages 3-5
-        if not any(stage in args.pipeline for stage in [1, 2]):
-            return
-
-        if self.exec_env == 'hpc.local':
-            self._hpc_local(args)
-        elif self.exec_env == 'hpc.adhoc':
-            self._hpc_adhoc(args)
-        elif self.exec_env == 'hpc.slurm':
-            self._hpc_slurm(args)
-        elif self.exec_env == 'hpc.pbs':
-            self._hpc_pbs(args)
-        else:
-            raise RuntimeError(f"'{self.exec_env}' unsupported on ROS1+Gazebo")
-
-    def _hpc_pbs(self, args: argparse.Namespace) -> None:
-        # For now, nothing to do. If more stuff with physics engine
-        # configuration is implemented, this may change.
-        self.logger.debug("Allocated %s physics threads/run, %s parallel runs/node",
-                          args.physics_n_threads,
-                          args.exec_jobs_per_node)
-
-    def _hpc_slurm(self, args: argparse.Namespace) -> None:
-        # We rely on the user to request their job intelligently so that
-        # SLURM_TASKS_PER_NODE is appropriate.
-        if args.exec_jobs_per_node is None:
-            res = re.search(r"^[^\(]+", os.environ['SLURM_TASKS_PER_NODE'])
-            assert res is not None, \
-                "Unexpected format in SLURM_TASKS_PER_NODE: '{0}'".format(
-                    os.environ['SLURM_TASKS_PER_NODE'])
-            args.exec_jobs_per_node = int(res.group(0))
-
-        self.logger.debug("Allocated %s physics threads/run, %s parallel runs/node",
-                          args.physics_n_threads,
-                          args.exec_jobs_per_node)
-
-    def _hpc_adhoc(self, args: argparse.Namespace) -> None:
-        nodes = platform.ExecEnvChecker.parse_nodefile(args.nodefile)
-        ppn = sys.maxsize
-        for node in nodes:
-            ppn = min(ppn, node.n_cores)
-
-        if args.exec_jobs_per_node is None:
-            args.exec_jobs_per_node = int(float(args.n_runs) / len(nodes))
-
-        self.logger.debug("Allocated %s physics threads/run, %s parallel runs/node",
-                          args.physics_n_threads,
-                          args.exec_jobs_per_node)
-
-    def _hpc_local(self, args: argparse.Namespace) -> None:
-        # For now. If more physics engine configuration is added, this will
-        # change.
-        ppn_per_run_req = 1
-
-        if args.exec_jobs_per_node is None:
-            parallel_jobs = int(psutil.cpu_count() / float(ppn_per_run_req))
-
-        if parallel_jobs == 0:
-            self.logger.warning(("Local machine has %s logical cores, but "
-                                 "%s threads/run requested; "
-                                 "allocating anyway"),
-                                psutil.cpu_count(),
-                                ppn_per_run_req)
-            parallel_jobs = 1
-
-        # Make sure we don't oversubscribe cores--each simulation needs at
-        # least 1 core.
-        args.exec_jobs_per_node = min(args.n_runs, parallel_jobs)
-
-        self.logger.debug("Allocated %s physics threads/run, %s parallel runs/node",
-                          args.physics_n_threads,
-                          args.exec_jobs_per_node)
-
-
-@implements.implements(bindings.IExpRunShellCmdsGenerator)
-class ExpRunShellCmdsGenerator():
-    def __init__(self,
-                 cmdopts: types.Cmdopts,
-                 criteria: bc.BatchCriteria,
-                 n_robots: int,
-                 exp_num: int) -> None:
-        self.cmdopts = cmdopts
-        self.gazebo_port = -1
-        self.roscore_port = -1
-
-    def pre_run_cmds(self,
-                     host: str,
-                     input_fpath: pathlib.Path,
-                     run_num: int) -> tp.List[types.ShellCmdSpec]:
-        if host == 'master':
-            return []
-
-        # First, the cmd to start roscore. We need to be on a unique port so
-        # that multiple ROS instances corresponding to multiple Gazebo
-        # instances with the same topic names are considered distinct/not
-        # accessible between instances of Gazebo.
-        self.roscore_port = config.kROS['port_base'] + run_num * 2
-
-        # roscore will run on each slave node used during stage 2, so we have to
-        # use 'localhost' for binding.
-        roscore_uri = types.ShellCmdSpec(
-            cmd=f'export ROS_MASTER_URI=http://localhost:{self.roscore_port};',
-            shell=True,
-            wait=True,
-            env=True)
-
-        # Each experiment gets their own roscore. Because each roscore has a
-        # different port, this prevents any robots from pre-emptively starting
-        # the next experiment before the rest of the robots have finished the
-        # current one.
-        roscore_process = types.ShellCmdSpec(
-            cmd=f'roscore -p {self.roscore_port} & ',
-            shell=True,
-            wait=False)
-
-        # Second, the command to give Gazebo a unique port on the host during
-        # stage 2. We need to be on a unique port so that multiple Gazebo
-        # instances can be run in parallel.
-        self.gazebo_port = config.kROS['port_base'] + run_num * 2 + 1
-
-        # 2021/12/13: You can't use HTTPS for some reason or gazebo won't
-        # start...
-        gazebo_uri = types.ShellCmdSpec(
-            cmd=f'export GAZEBO_MASTER_URI=http://localhost:{self.gazebo_port};',
-            shell=True,
-            env=True,
-            wait=True
-        )
-
-        return [roscore_uri, roscore_process, gazebo_uri]
-
-    def exec_run_cmds(self,
-                      host: str,
-                      input_fpath: pathlib.Path,
-                      run_num: int) -> tp.List[types.ShellCmdSpec]:
-        if host == 'master':
-            return []
-
-        # For ROS+gazebo, we have two files per experimental run:
-        #
-        # - One for the stuff that is run on the ROS master (can be
-        #   nothing/empty file).
-        #
-        # - One for the stuff that describes what to run on each robot/how many
-        #   robots to spawn.
-        #
-        # We COULD do it all in a single file, but in order to share base code
-        # with the ROS+robot platform, we need to do it this way.
-        #
-        # 2022/02/28: I don't use the -u argument here to set ROS_MASTER_URI,
-        # because ROS works well enough when only running on the localhost, in
-        # terms of respecting whatever the envvar is set to.
-        master = str(input_fpath) + "_master" + config.kROS['launch_file_ext']
-        robots = str(input_fpath) + "_robots" + config.kROS['launch_file_ext']
-
-        cmd = '{0} --wait {1} {2} '.format(config.kROS['launch_cmd'],
-                                           master,
-                                           robots)
-
-        # ROS/Gazebo don't provide options to not print stuff, so we have to use
-        # the nuclear option.
-        if self.cmdopts['exec_devnull']:
-            cmd += '2>&1 > /dev/null'
-
-        cmd += ';'
-
-        return [types.ShellCmdSpec(cmd=cmd, shell=True, wait=True)]
-
-    def post_run_cmds(self, host: str) -> tp.List[types.ShellCmdSpec]:
-        return []
-
-
-@implements.implements(bindings.IExpShellCmdsGenerator)
-class ExpShellCmdsGenerator():
-    def __init__(self,
-                 cmdopts: types.Cmdopts,
-                 exp_num: int) -> None:
-        self.cmdopts = cmdopts
-        self.exp_num = exp_num
-
-    def pre_exp_cmds(self) -> tp.List[types.ShellCmdSpec]:
-        return []
-
-    def exec_exp_cmds(self,
-                      exec_opts: types.StrDict) -> tp.List[types.ShellCmdSpec]:
-        return []
-
-    def post_exp_cmds(self) -> tp.List[types.ShellCmdSpec]:
-        # Cleanup roscore and gazebo processes which are still active because
-        # they don't know how to clean up after themselves.
-        #
-        # This is OK to do even when we have multiple Gazebo+ROS instances on
-        # the same machine, because we only run these commands after an
-        # experiment finishes, so there isn't anything currently running we
-        # might accidentally kill.
-        #
-        # Can't use killall, because that returns non-zero if things
-        # are cleaned up nicely.
-        return [types.ShellCmdSpec(cmd='if pgrep gzserver; then pkill gzserver; fi;',
-                                   shell=True,
-                                   wait=True),
-                types.ShellCmdSpec(cmd='if pgrep rosmaster; then pkill rosmaster; fi;',
-                                   shell=True,
-                                   wait=True),
-                types.ShellCmdSpec(cmd='if pgrep roscore; then pkill roscore; fi;',
-                                   shell=True,
-                                   wait=True),
-                types.ShellCmdSpec(cmd='if pgrep rosout; then pkill rosout; fi;',
-                                   shell=True,
-                                   wait=True)]
-
-
-@implements.implements(bindings.IExpConfigurer)
-class ExpConfigurer():
-    def __init__(self, cmdopts: types.Cmdopts) -> None:
-        self.cmdopts = cmdopts
-
-    def for_exp_run(self,
-                    exp_input_root: pathlib.Path,
-                    run_output_root: pathlib.Path) -> None:
-        pass
-
-    def for_exp(self, exp_input_root: pathlib.Path) -> None:
-        pass
-
-    def cmdfile_paradigm(self) -> str:
-        return 'per-exp'
-
-
-@implements.implements(bindings.IExecEnvChecker)
-class ExecEnvChecker(platform.ExecEnvChecker):
-    def __init__(self, cmdopts: types.Cmdopts) -> None:
-        super().__init__(cmdopts)
-
-    def __call__(self) -> None:
-        keys = ['ROS_DISTRO', 'ROS_VERSION']
-
-        for k in keys:
-            assert k in os.environ,\
-                f"Non-ROS+Gazebo environment detected: '{k}' not found"
-
-        # Check ROS distro
-        assert os.environ['ROS_DISTRO'] in ['kinetic', 'noetic'],\
-            "SIERRA only supports ROS1 kinetic,noetic"
-
-        # Check ROS version
-        assert os.environ['ROS_VERSION'] == "1",\
-            "Wrong ROS version: this plugin is for ROS1"
-
-        # Check we can find Gazebo
-        version = self.check_for_simulator(config.kGazebo['launch_cmd'])
-
-        # Check Gazebo version
-        res = re.search(r'[0-9]+.[0-9]+.[0-9]+', version.stdout.decode('utf-8'))
-        assert res is not None, "Gazebo version not in -v output"
-
-        version = packaging.version.parse(res.group(0))
-        min_version = packaging.version.parse(config.kGazebo['min_version'])
-
-        assert version >= min_version,\
-            f"Gazebo version {version} < min required {min_version}"
-
-
-def population_size_from_pickle(adds_def: tp.Union[xml.AttrChangeSet,
-                                                   xml.TagAddList],
-                                main_config: types.YAMLDict,
-                                cmdopts: types.Cmdopts) -> int:
-    return ros1.callbacks.population_size_from_pickle(adds_def,
-                                                      main_config,
-                                                      cmdopts)
-
-
-def population_size_from_def(exp_def: definition.XMLExpDef,
-                             main_config: types.YAMLDict,
-                             cmdopts: types.Cmdopts) -> int:
-    return ros1.callbacks.population_size_from_def(exp_def,
-                                                   main_config,
-                                                   cmdopts)
-
-
-def robot_prefix_extract(main_config: types.YAMLDict,
-                         cmdopts: types.Cmdopts) -> str:
-    return ros1.callbacks.robot_prefix_extract(main_config, cmdopts)
-
-
-def pre_exp_diagnostics(cmdopts: types.Cmdopts,
-                        logger: logging.Logger) -> None:
-    s = "batch_exp_root='%s',runs/exp=%s,threads/job=%s,n_jobs=%s"
-    logger.info(s,
-                cmdopts['batch_root'],
-                cmdopts['n_runs'],
-                cmdopts['physics_n_threads'],
-                cmdopts['exec_jobs_per_node'])

sierra/plugins/platform/ros1gazebo/variables/__init__.py

@@ -1,10 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-
-# Core packages
-
-# 3rd party packages
-
-# Project packages
-from sierra.core.ros1.variables import exp_setup

sierra/plugins/platform/ros1gazebo/variables/population_size.py

@@ -1,204 +0,0 @@
-# Copyright 2020 John Harwell, All rights reserved.
-#
-# SPDX-License-Identifier: MIT
-"""Classes for the population size batch criteria.
-
-See :ref:`ln-sierra-platform-ros1gazebo-bc-population-size` for usage
-documentation.
-
-"""
-
-# Core packages
-import typing as tp
-import random
-import logging
-import pathlib
-
-# 3rd party packages
-import implements
-
-# Project packages
-from sierra.core.variables import batch_criteria as bc
-from sierra.core.experiment import xml
-from sierra.core import types, utils
-from sierra.core.vector import Vector3D
-from sierra.core.variables import population_size
-
-
-@implements.implements(bc.IConcreteBatchCriteria)
-@implements.implements(bc.IQueryableBatchCriteria)
-class PopulationSize(population_size.BasePopulationSize):
-    """A univariate range of system sizes used to define batch experiments.
-
-    This class is a base class which should (almost) never be used on its
-    own. Instead, the ``factory()`` function should be used to dynamically
-    create derived classes expressing the user's desired size distribution.
-
-    Note: Usage of this class assumes homogeneous systems.
-
-    Attributes:
-
-        size_list: List of integer system sizes defining the range of the
-                   variable for the batch experiment.
-
-    """
-
-    def __init__(self,
-                 cli_arg: str,
-                 main_config: types.YAMLDict,
-                 batch_input_root: pathlib.Path,
-                 robot: str,
-                 sizes: tp.List[int],
-                 positions: tp.List[Vector3D]) -> None:
-        population_size.BasePopulationSize.__init__(self,
-                                                    cli_arg,
-                                                    main_config,
-                                                    batch_input_root)
-        self.sizes = sizes
-        self.robot = robot
-        self.positions = positions
-        self.logger = logging.getLogger(__name__)
-        if len(positions) < self.sizes[-1]:
-            self.logger.warning("# possible positions < # robots: %s < %s",
-                                len(positions),
-                                self.sizes[-1])
-        self.tag_adds = []  # type: tp.List[xml.TagAddList]
-
-    def gen_tag_addlist(self) -> tp.List[xml.TagAddList]:
-        """Generate XML modifications to set system sizes.
-
-        """
-        if not self.tag_adds:
-            robot_config = self.main_config['ros']['robots'][self.robot]
-            prefix = robot_config['prefix']
-            model_base = robot_config['model']
-            model_variant = robot_config.get('model_variant', '')
-
-            if model_variant != '':
-                model = f"{model_base}_{model_variant}"
-            else:
-                model = model_base
-
-            desc_cmd = f"$(find xacro)/xacro $(find {model_base}_description)/urdf/{model}.urdf.xacro"
-            for s in self.sizes:
-                exp_adds = xml.TagAddList()
-                pos_i = random.randint(0, len(self.positions) - 1)
-
-                exp_adds.append(xml.TagAdd(".",
-                                           "master",
-                                           {},
-                                           True))
-                exp_adds.append(xml.TagAdd("./master",
-                                           "group",
-                                           {
-                                               'ns': 'sierra'
-                                           },
-                                           False))
-                exp_adds.append(xml.TagAdd("./master/group/[@ns='sierra']",
-                                           "param",
-                                           {
-                                               'name': 'experiment/n_robots',
-                                               'value': str(s)
-                                           },
-                                           False))
-
-                for i in range(0, s):
-
-                    ns = f'{prefix}{i}'
-                    pos = self.positions[pos_i]
-                    pos_i = (pos_i + 1) % len(self.positions)
-                    spawn_cmd_args = f"-urdf -model {model}_{ns} -x {pos.x} -y {pos.y} -z {pos.z} -param robot_description"
-
-                    exp_adds.append(xml.TagAdd("./robot",
-                                               "group",
-                                               {
-                                                   'ns': ns
-                                               },
-                                               True))
-
-                    exp_adds.append(xml.TagAdd(f"./robot/group/[@ns='{ns}']",
-                                               "param",
-                                               {
-                                                   "name": "tf_prefix",
-                                                   "value": ns
-                                               },
-                                               True))
-
-                    # These two tag adds are OK to use because:
-                    #
-                    # - All robots in Gazebo are created using spawn_model
-                    #   initially.
-                    #
-                    # - All robots in Gazebo will provide a robot description
-                    #   .urdf.xacro per ROS naming conventions
-                    exp_adds.append(xml.TagAdd(f"./robot/group/[@ns='{ns}']",
-                                               "param",
-                                               {
-                                                   "name": "robot_description",
-                                                   "command": desc_cmd
-                                               },
-                                               True))
-
-                    exp_adds.append(xml.TagAdd(f"./robot/group/[@ns='{ns}']",
-                                               "node",
-                                               {
-                                                   "name": "spawn_urdf",
-                                                   "pkg": "gazebo_ros",
-                                                   "type": "spawn_model",
-                                                   "args": spawn_cmd_args
-                                               },
-                                               True))
-
-                self.tag_adds.append(exp_adds)
-
-        return self.tag_adds
-
-    def gen_exp_names(self, cmdopts: types.Cmdopts) -> tp.List[str]:
-        adds = self.gen_tag_addlist()
-        return ['exp' + str(x) for x in range(0, len(adds))]
-
-    def n_robots(self, exp_num: int) -> int:
-        return int(len(self.tag_adds[exp_num]) / len(self.tag_adds[0]))
-
-
-def factory(cli_arg: str,
-            main_config: types.YAMLDict,
-            cmdopts: types.Cmdopts,
-            **kwargs) -> PopulationSize:
-    """Create a :class:`PopulationSize` derived class from the cmdline definition.
-
-    """
-    parser = population_size.Parser()
-    attr = parser(cli_arg)
-    max_sizes = parser.to_sizes(attr)
-
-    if cmdopts['robot_positions']:
-        positions = [Vector3D.from_str(s,
-                                       astype=float) for s in cmdopts['robot_positions']]
-    else:
-        # Get the dimensions of the effective arena from the scenario so we can
-        # place robots randomly within it.
-        kw = utils.gen_scenario_spec(cmdopts, **kwargs)
-
-        xs = random.choices(range(0, kw['arena_x']), k=max_sizes[-1])  # type: ignore
-        ys = random.choices(range(0, kw['arena_y']), k=max_sizes[-1])  # type: ignore
-        zs = random.choices(range(0, kw['arena_z']), k=max_sizes[-1])  # type: ignore
-        positions = [Vector3D(x, y, z) for x, y, z in zip(xs, ys, zs)]
-
-    def __init__(self) -> None:
-        PopulationSize.__init__(self,
-                                cli_arg,
-                                main_config,
-                                cmdopts['batch_input_root'],
-                                cmdopts['robot'],
-                                max_sizes,
-                                positions)
-
-    return type(cli_arg,  # type: ignore
-                (PopulationSize,),
-                {"__init__": __init__})
-
-
-__api__ = [
-    'PopulationSize'
-]

sierra/plugins/platform/ros1robot/__init__.py

@@ -1,9 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-
-# Core packages
-
-# 3rd party packages
-
-# Project packages