opencos-eda 0.2.32__tar.gz → 0.2.33__tar.gz

{opencos_eda-0.2.32/opencos_eda.egg-info → opencos_eda-0.2.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.32
+Version: 0.2.33
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos

{opencos_eda-0.2.32 → opencos_eda-0.2.33}/opencos/commands/multi.py

@@ -268,26 +268,23 @@ class CommandMulti(CommandParallel):
         if parsed.parallel < 1 or parsed.parallel > 256:
             self.error("Arg 'parallel' must be between 1 and 256")
 
-        for value in unparsed:
-            if value in self.config['command_handler'].keys():
-                command = value
-                unparsed.remove(value)
-                break
+        command = self.get_command_from_unparsed_args(tokens=unparsed)
 
         # Need to know the tool for this command, either it was set correctly via --tool and/or
         # the command (class) will tell us.
         all_multi_tools = self.multi_which_tools(command)
 
+        single_cmd_unparsed = self.get_unparsed_args_on_single_command(
+            command=command, tokens=unparsed
+        )
+
         util.debug(f"Multi: {unparsed=}, looking for target_globs")
         for token in unparsed:
-            if token.startswith("-") or token.startswith("+"):
-                # save all --arg, -arg, or +plusarg for the job target:
-                arg_tokens.append(token)
-            else:
+            if token in single_cmd_unparsed:
                 target_globs.append(token)
+            else:
+                arg_tokens.append(token)
 
-        if command == "":
-            self.error("Didn't get a command after 'multi'!")
 
         # now we need to expand the target list
         self.single_command = command
@@ -379,27 +376,23 @@ class CommandMulti(CommandParallel):
         # Do not use for CommandMulti, b/c we support list of tools.
         raise NotImplementedError
 
-    def multi_which_tools(self, command):
+    def multi_which_tools(self, command) -> list:
         '''returns a list, or None, of the tool that was already determined to run the command
 
         CommandToolsMulti will override and return its own list'''
         return [eda_base.which_tool(command, config=self.config)]
 
-    def _append_job_command_args(self, command_list: list) -> None:
-        # Many args were consumed by eda before CommandMulti saw them
-        # --config-yml, --tool, --eda-safe. Some are in self.config.
-        # We need to apply those eda level args to each multi exec-command
-        # TODO(drew): this is really clunky. It would be way eaiser if our
-        # self.config['eda_original_args'] had a better way of passing allow-listed
-        # args from multi --> exec-command.
-        # Alternatively, we could track all the parsed args up to this point, that have
-        # deviated from the default value(s), and apply those as needed.
-        if any(a.startswith('--config-yml') for a in self.config['eda_original_args']):
-            cfg_yml_fname = self.config.get('config-yml', None)
-            if cfg_yml_fname:
-                command_list.append(f'--config-yml={cfg_yml_fname}')
-        if '--eda-safe' in self.config['eda_original_args']:
-            command_list.append('--eda-safe')
+    def _append_job_command_args( # pylint: disable=R0913,R0917 # too-many-arguments
+            self, command_list: list, tool: str, all_multi_tools: list, short_target: str,
+            command: str
+    ) -> None:
+
+        super().update_args_list(args=command_list, tool=tool)
+        if self.args.get('export-jsonl', False):
+            # Special case for 'multi' --export-jsonl, run reach child with --export-json
+            command_list.append('--export-json')
+        if tool and len(all_multi_tools) > 1:
+            command_list.append(f'--sub-work-dir={short_target}.{command}.{tool}')
 
     def append_jobs_from_targets(self, args:list):
         '''Helper method in CommandMulti to apply 'args' (list) to all self.targets,
@@ -422,17 +415,11 @@ class CommandMulti(CommandParallel):
 
             _, short_target = os.path.split(target) # trim path info on left
 
-            self._append_job_command_args(command_list=command_list)
+            self._append_job_command_args(
+                command_list=command_list, tool=tool, all_multi_tools=all_multi_tools,
+                short_target=short_target, command=command
+            )
 
-            if tool:
-                # tool can be None, we won't add it to the command (assumes default from config-yml)
-                command_list.append('--tool=' + tool)
-                if len(all_multi_tools) > 1:
-                    command_list += [f'--sub-work-dir={short_target}.{command}.{tool}']
-
-            if self.args.get('export-jsonl', False):
-                # Special case for 'multi' --export-jsonl, run reach child with --export-json
-                command_list += [ '--export-json']
             # if self.args['parallel']: command_list += ['--quiet']
             command_list += args # put the args prior to the target.
             command_list += [target]
@@ -540,6 +527,8 @@ class CommandMulti(CommandParallel):
                                                     output_json_path=output_json_path)
 
 
+
+
 class CommandToolsMulti(CommandMulti):
     '''eda.py command handler for: eda tools-multi <args,targets,target-globs,...>
 

opencos_eda-0.2.33/opencos/commands/sweep.py

@@ -0,0 +1,230 @@
+'''opencos.commands.sweep - command handler for: eda sweep ...
+
+These are not intended to be overriden by child classes. They do not inherit Tool classes.
+'''
+
+import os
+import re
+
+from opencos import util
+from opencos.eda_base import CommandDesign, CommandParallel, get_eda_exec, which_tool
+
+class CommandSweep(CommandDesign, CommandParallel):
+    '''Command handler for: eda sweep ...'''
+
+    command_name = 'sweep'
+
+    def __init__(self, config:dict):
+        CommandDesign.__init__(self, config=config)
+        CommandParallel.__init__(self, config=config)
+        self.sweep_target = ''
+        self.single_command = ''
+        self.args.update({
+            'sweep': []
+        })
+        self.args_help.update({
+            "sweep": ("List append arg, where range or value expansion is peformed on the RHS:"
+                      " --sweep='--arg0=(start,last,iter=1)' "
+                      " --sweep='--arg1=[val0,val1,val2,...]' "
+                      " --sweep='+define+NAME0=(start,last,iter=1)' "
+                      " --sweep='+define+NAME1=[val0,val1,val2,...]' "
+                      " --sweep='+define+[NAME0,NAME1,NAME2,...]' ."
+                      " Note that range expansion of (1,4) will expand to values [1,2,3,4]."
+                      ),
+        })
+
+
+    def check_args(self) -> None:
+        '''Returns None, checks self.args (use after args parsed)'''
+        if self.args['parallel'] < 1 or self.args['parallel'] > 256:
+            self.error(f"Arg {self.args['parallel']=} must be between 1 and 256")
+
+    def _append_sweep_args(self, arg_tokens: list) -> None:
+        '''Modifies list arg_tokens, using known top-level args'''
+        tool = which_tool(command=self.single_command, config=self.config)
+        super().update_args_list(args=arg_tokens, tool=tool)
+
+
+    def process_tokens(
+            self, tokens: list, process_all: bool = True,
+            pwd: str = os.getcwd()
+    ) -> list:
+        '''CommandSweep.process_tokens(..) is likely the entry point for: eda sweep <command> ...
+
+        - handles remaining CLI arguments (tokens list)
+        - builds sweep_axis_list to run multiple jobs for the target
+        '''
+
+        # 'sweep' is special in the way it handles tokens, due to most of them being processed by
+        # a sub instance
+        sweep_axis_list = []
+        arg_tokens = []
+
+        _, unparsed = self.run_argparser_on_list(
+            tokens=tokens,
+            parser_arg_list=[
+                'parallel',
+                'sweep',
+            ],
+            apply_parsed_args=True
+        )
+
+        self.check_args()
+
+        self.single_command = self.get_command_from_unparsed_args(tokens=unparsed)
+
+        self._append_sweep_args(arg_tokens=arg_tokens)
+
+        for sweep_arg_value in self.args['sweep']:
+            # Deal with --sweep= args we already parsed, but haven't expanded yet.
+            sweep_arg_value = util.strip_outer_quotes(sweep_arg_value)
+            sweep_axis_list_entry = self._process_sweep_arg(sweep_arg_value=sweep_arg_value)
+            if sweep_axis_list_entry:
+                sweep_axis_list.append(sweep_axis_list_entry)
+
+
+        # command, --parallel, and --sweep already processed by argparse,
+        # let's tentatively parse what the child jobs cannot consume.
+        # Whatever is leftover is either an eda target, or another unparsed token.
+        single_cmd_unparsed = self.get_unparsed_args_on_single_command(
+            command=self.single_command, tokens=unparsed
+        )
+
+        for token in unparsed:
+            if token in single_cmd_unparsed:
+
+                if self.resolve_target(token, no_recursion=True):
+                    if self.sweep_target:
+                        self.error("Sweep can only take one target, already got",
+                                   f"{self.sweep_target} now getting {token}")
+                    self.sweep_target = token
+                else:
+                    # If we don't know what to do with it, pass it to downstream
+                    arg_tokens.append(token)
+
+            else:
+                # If it wasn't in single_cmd_unparsed, then it can definitely be
+                # consumed downstream
+                arg_tokens.append(token)
+
+
+        # now we need to expand the target list
+        util.debug(f"Sweep: command:    '{self.single_command}'")
+        util.debug(f"Sweep: arg_tokens: '{arg_tokens}'")
+        util.debug(f"Sweep: target:     '{self.sweep_target}'")
+
+        # now create the list of jobs, support one axis
+        self.jobs = []
+
+        self.expand_sweep_axis(arg_tokens=arg_tokens, sweep_axis_list=sweep_axis_list)
+        self.run_jobs(command=self.single_command)
+        return [] # we used all of unparsed.
+
+
+    @staticmethod
+    def _process_sweep_arg(sweep_arg_value: str) -> dict:
+        '''If processed, returns a non-empty dict. Handles processing of --sweep=VALUE
+
+        Where VALUE could be one of:
+           --arg0=(1,4)
+           --arg1=[val0,val1]
+           +define+NAME0=[val0,val1]
+
+        Return value is {} or {'lhs': str, 'operator': str (+ or =), 'values': list}
+        '''
+
+        sweep_arg_value = util.strip_outer_quotes(sweep_arg_value)
+
+        util.debug(f'{sweep_arg_value=}')
+        # Try to match a sweep range expansion:
+        #   --sweep='--arg0=(1,4)'
+        #   --sweep='--arg0=(1,4,1)'
+        #   --sweep='+define+NAME0=(1,4,1)'
+        m = re.match(
+            r'(.*)(\=) \(  ([\d\.]+)  \,  ([\d\.]+)  (\, ([\d\.]+) )?  \)'.replace(' ',''),
+            sweep_arg_value
+        )
+        if m:
+            lhs = m.group(1)
+            operator = m.group(2)
+            sweep_axis_values = []
+            if m.group(5):
+                rhs_range_iter = int(m.group(6))
+            else:
+                rhs_range_iter = 1
+            for v in range(int(m.group(3)), int(m.group(4)) + 1, rhs_range_iter):
+                sweep_axis_values.append(v)
+            util.debug(f"Sweep axis: {lhs} {operator} {sweep_axis_values}")
+            return {
+                'lhs': lhs,
+                'operator': operator,
+                'values': sweep_axis_values,
+            }
+
+        # Try to match a sweep list value expansion:
+        #   --sweep='--arg0=[1,2]'
+        #   --sweep='--arg1=[3,4,5,6]'
+        #   --sweep='+define+NAME=[8,9]'
+        #   --sweep='+define+[NAME0,NAME1,NAME2]'
+        #   --sweep='+define+[NAME0=1,NAME1=22,NAME2=46]'
+        m = re.match(
+            r'(.*)([\=\+]) \[  ([^\]]+) \] '.replace(' ',''),
+            sweep_arg_value
+        )
+        if m:
+            sweep_axis_values = []
+            lhs = m.group(1)
+            operator = m.group(2)
+            for v in m.group(3).split(','):
+                sweep_axis_values.append(v)
+            util.debug(f"Sweep axis: {lhs} {operator} {sweep_axis_values}")
+            return {
+                'lhs': lhs,
+                'operator': operator,
+                'values': sweep_axis_values,
+            }
+
+        util.warning(f'Ignored unprocessed expansion for --sweep={sweep_arg_value}')
+        return {}
+
+
+    def expand_sweep_axis(
+            self, arg_tokens: list, sweep_axis_list: list, sweep_string: str = ""
+    ) -> None:
+        '''Returns None, appends jobs to self.jobs to be run by CommandParallel.run_jobs(..)'''
+
+        util.debug(f"Entering expand_sweep_axis: command={self.single_command},",
+                   f"target={self.sweep_target}, arg_tokens={arg_tokens},",
+                   f"sweep_axis_list={sweep_axis_list}")
+        if not sweep_axis_list:
+            # we aren't sweeping anything, create one job
+            snapshot_name = self.sweep_target.replace('../','').replace('/','_') + sweep_string
+            eda_path = get_eda_exec('sweep')
+            self.jobs.append({
+                'name' : snapshot_name,
+                'index' : len(self.jobs),
+                'command_list' : (
+                    [eda_path, self.single_command, self.sweep_target,
+                     '--job_name', snapshot_name] + arg_tokens
+                )
+            })
+            return
+
+        sweep_axis = sweep_axis_list.pop(0)
+        lhs = sweep_axis['lhs']
+        operator = sweep_axis['operator']
+
+        lhs_trimmed = lhs.replace('-', '').replace('+', '').replace('=', '')
+
+        for v in sweep_axis['values']:
+            this_arg_tokens = arg_tokens.copy()
+            this_arg_tokens.append(f'{lhs}{operator}{v}')
+
+            v_string = f"{v}".replace('.','p')
+            this_sweep_string = sweep_string + f"_{lhs_trimmed}_{v_string}"
+
+            self.expand_sweep_axis(
+                arg_tokens=this_arg_tokens,
+                sweep_axis_list=sweep_axis_list,
+                sweep_string=this_sweep_string
+            )

{opencos_eda-0.2.32 → opencos_eda-0.2.33}/opencos/deps_schema.py

@@ -125,7 +125,7 @@ import sys
 
 from schema import Schema, Or, Optional, SchemaError
 
-from opencos.deps_helpers import deps_markup_safe_load, get_deps_markup_file
+from opencos import util, deps_helpers
 
 # Because we deal with YAML, where a Table Key with dangling/empty value is allowed
 # and we have things like SystemVerilog defines where there's a Table key with no Value,
@@ -299,8 +299,10 @@ FILE_SIMPLIFIED = Schema(
 
 
 
-def check(data: dict, schema_obj=FILE):
+def check(data: dict, schema_obj=FILE) -> (bool, str):
     '''Returns (bool, str) for checking dict against FILE schema'''
+
+
     try:
         schema_obj.validate(data)
         return True, None
@@ -310,6 +312,37 @@ def check(data: dict, schema_obj=FILE):
         return False, str(e)
 
 
+def deps_markup_safe_load(deps_filepath: str) -> (bool, dict):
+    '''Returns tuple (bool False if took errors, dict of markp data)'''
+    current_errors = util.args['errors']
+    data = deps_helpers.deps_markup_safe_load(deps_filepath)
+    if util.args['errors'] > current_errors:
+        return False, data
+    return True, data
+
+
+def check_file(filepath: str, schema_obj=FILE) -> (bool, str, str):
+    '''Returns tuple (bool pass/fail, str error retdata, str deps_filepath)'''
+
+    deps_filepath = filepath
+    if os.path.isdir(filepath):
+        deps_filepath = deps_helpers.get_deps_markup_file(base_path=filepath)
+
+    # get deps file
+    if not os.path.exists(deps_filepath):
+        print(f'ERROR: internal error(s) no DEPS.[yml|..] found in {filepath=}')
+        return False, '', deps_filepath
+
+    passes, data = deps_markup_safe_load(deps_filepath)
+    if not passes:
+        print(f'ERROR: internal error(s) from deps_markup_safe_load({deps_filepath=})')
+        return False, '', deps_filepath
+
+    passes, retdata = check(data, schema_obj)
+    return passes, retdata, deps_filepath
+
+
+
 def check_files(files, schema_obj=FILE) -> bool:
     '''Returns True if files lint cleanly in the FILE schema.'''
 
@@ -319,20 +352,16 @@ def check_files(files, schema_obj=FILE) -> bool:
     passes_list = []
     error_files = []
     for filepath in files:
-        deps_filepath = filepath
-        if os.path.isdir(filepath):
-            # get deps file
-            deps_filepath = get_deps_markup_file(base_path=filepath)
-        assert os.path.exists(deps_filepath)
-        data = deps_markup_safe_load(deps_filepath)
-        passes, retdata = check(data, schema_obj)
+
+        passes, retdata, deps_filepath = check_file(filepath, schema_obj)
         passes_list.append(passes)
         if passes:
             print(f'{deps_filepath}: [PASS]')
         if not passes:
             print(f'ERROR: {deps_filepath}:')
-            print('-- retdata --')
-            print(retdata)
+            if retdata:
+                print('-- retdata --')
+                print(retdata)
             print(f'    previous error on: {deps_filepath}\n')
             error_files.append(deps_filepath)
 

{opencos_eda-0.2.32 → opencos_eda-0.2.33}/opencos/eda_base.py

@@ -398,12 +398,6 @@ class Command:
             else:
                 assert False, f'{key=} {value=} how do we do argparse for this type of value?'
 
-        # TODO(drew): it might be nice to support positional args here as a list
-        # self.target_args (files/targets/patterns), something like:
-        #    parser.add_argument(
-        #        'targets', nargs='+', help='positional arg for targets/files/pattern'
-        #    )
-
         return parser
 
 
@@ -425,7 +419,7 @@ class Command:
             parsed, unparsed = parser.parse_known_args(tokens + [''])
             unparsed = list(filter(None, unparsed))
         except argparse.ArgumentError:
-            self.error(f'problem attempting to parse_known_args for {tokens=}')
+            self.error(f'problem {command_name=} attempting to parse_known_args for {tokens=}')
 
         parsed_as_dict = vars(parsed)
 
@@ -506,7 +500,8 @@ class Command:
                 break
 
         if not ret and error_if_no_command:
-            self.error(f"Looking for a valid eda <command> but didn't find one in {tokens=}")
+            self.error(f"Looking for a valid eda {self.command_name} <command>",
+                       f"but didn't find one in {tokens=}")
         return ret
 
 
@@ -1518,3 +1513,57 @@ class CommandParallel(Command):
         if self.status == 0:
             self.status = 0 if len(self.jobs_status) == 0 else max(self.jobs_status)
         util.fancy_stop()
+
+
+    def update_args_list(self, args: list, tool: str) -> None:
+        '''Modfies list args, using allow-listed known top-level args:
+
+        --config-yml
+        --eda-safe
+        --tool
+
+        Many args were consumed by eda before CommandParallel saw them
+        (for commands like 'multi' or 'sweep'). Some are in self.config.
+         We need to apply those eda level args to each single exec-command
+        '''
+        if any(a.startswith('--config-yml') for a in self.config['eda_original_args']):
+            cfg_yml_fname = self.config.get('config-yml', None)
+            if cfg_yml_fname:
+                args.append(f'--config-yml={cfg_yml_fname}')
+        if '--eda-safe' in self.config['eda_original_args']:
+            args.append('--eda-safe')
+        if tool:
+            # tool can be None, if so we won't add it to the command (assumes default from
+            # config-yml auto load order)
+            args.append('--tool=' + tool)
+
+
+    def get_unparsed_args_on_single_command(self, command: str, tokens: list) -> list:
+        '''Returns a list of args that the single (non-multi) command cannot parse
+
+        This will error on bad --args or -arg, such as:
+          eda multi sim --seeeed=1
+        is not a valid arg in CommandSim
+
+        +arg=value, +arg+value will not be included in the return list, those are
+        intended to be consumed by the single/job command downstream (anything starting
+        with '+')
+
+        Used by CommandMulti and CommandSweep.
+        '''
+        single_cmd_handler = self.config['command_handler'][command](config=self.config)
+        single_cmd_parsed, single_cmd_unparsed = single_cmd_handler.run_argparser_on_list(
+            tokens=tokens.copy(),
+            apply_parsed_args=False,
+        )
+        util.debug(f'{self.command_name}: {single_cmd_unparsed=}')
+
+        # There should not be any single_cmd_unparsed args starting with '-'
+        bad_remaining_args = [x for x in single_cmd_unparsed if x.startswith('-')]
+        if bad_remaining_args:
+            self.error(f'for {self.command_name} {command=} the following args are unknown',
+                       f'{bad_remaining_args}')
+
+        # Remove unparsed args starting with '+', since those are commonly sent downstream to
+        # single job (example, CommandSim plusargs).
+        return [x for x in single_cmd_unparsed if not x.startswith('+')]

{opencos_eda-0.2.32 → opencos_eda-0.2.33/opencos_eda.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.32
+Version: 0.2.33
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos

{opencos_eda-0.2.32 → opencos_eda-0.2.33}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [project]
 name = "opencos-eda"
-version = "0.2.32"
+version = "0.2.33"
 dependencies = [
   # opencos/eda.py dependencies
   "mergedeep >= 1.3.4",

opencos_eda-0.2.32/opencos/commands/sweep.py

@@ -1,170 +0,0 @@
-'''opencos.commands.sweep - command handler for: eda sweep ...
-
-These are not intended to be overriden by child classes. They do not inherit Tool classes.
-'''
-
-import os
-import re
-
-from opencos import util
-from opencos.eda_base import CommandDesign, CommandParallel, get_eda_exec
-
-class CommandSweep(CommandDesign, CommandParallel):
-    '''Command handler for: eda sweep ...'''
-
-    command_name = 'sweep'
-
-    def __init__(self, config:dict):
-        CommandDesign.__init__(self, config=config)
-        CommandParallel.__init__(self, config=config)
-        self.sweep_target = ''
-        self.single_command = ''
-
-
-    def check_args(self) -> None:
-        '''Returns None, checks self.args (use after args parsed)'''
-        if self.args['parallel'] < 1 or self.args['parallel'] > 256:
-            self.error(f"Arg {self.args['parallel']=} must be between 1 and 256")
-
-    def _append_sweep_args(self, arg_tokens: list) -> None:
-        '''Modifies list arg_tokens, bit of a hack'''
-
-        # TODO(drew): similar clunky behavior with self.config['eda_orignal_args'] that
-        # CommandMulti has we need to pass global args to each sweep job, which we can
-        # do via arg_tokens (list)
-        # TODO(drew): fix this, for now it works but --color and other args do not work.
-        if any(a.startswith('--config-yml') for a in self.config['eda_original_args']):
-            cfg_yml_fname = self.config.get('config-yml', None)
-            if cfg_yml_fname:
-                arg_tokens.append(f'--config-yml={cfg_yml_fname}')
-        if '--eda-safe' in self.config['eda_original_args']:
-            arg_tokens.append('--eda-safe')
-        if any(a.startswith('--tool') for a in self.config['eda_original_args']):
-            tool = self.config.get('tool', None)
-            if tool:
-                arg_tokens.append('--tool=' + tool)
-
-
-    def process_tokens(
-            self, tokens: list, process_all: bool = True,
-            pwd: str = os.getcwd()
-    ) -> list:
-        '''CommandSweep.process_tokens(..) is likely the entry point for: eda sweep <command> ...
-
-        - handles remaining CLI arguments (tokens list)
-        - builds sweep_axis_list to run multiple jobs for the target
-        '''
-
-        # multi is special in the way it handles tokens, due to most of them being processed by
-        # a sub instance
-        sweep_axis_list = []
-        arg_tokens = []
-
-        _, unparsed = self.run_argparser_on_list(
-            tokens=tokens,
-            parser_arg_list=[
-                'parallel',
-            ],
-            apply_parsed_args=True
-        )
-
-        self.check_args()
-
-        tokens = unparsed
-
-        self.single_command = self.get_command_from_unparsed_args(tokens=tokens)
-
-        self._append_sweep_args(arg_tokens=arg_tokens)
-
-        while tokens:
-            token = tokens.pop(0)
-
-            # command and --parallel already processed by argparse
-
-            m = re.match(r'(\S+)\=\(([\d\.]+)\,([\d\.]+)(,([\d\.]+))?\)', token)
-            if m:
-                # Form --arg=CUST "CUST=(range-start,range-stop,range-step)"
-                sweep_axis = { 'key' : m.group(1),
-                               'values' : [  ] }
-                for v in range(
-                        int(m.group(2)),
-                        int(m.group(3)) + 1,
-                        int(m.group(5)) if m.group(4) else 1
-                ):
-                    sweep_axis['values'].append(v)
-                util.debug(f"Sweep axis: {sweep_axis['key']} : {sweep_axis['values']}")
-                sweep_axis_list.append(sweep_axis)
-                continue
-            m = re.match(r'(\S+)\=\[([^\]]+)\]', token)
-            if m:
-                # Form --arg=CUST "CUST=[val0,val1,val2,...]"
-                sweep_axis = { 'key' : m.group(1), 'values' : [] }
-                for v in m.group(2).split(','):
-                    v = v.replace(' ','')
-                    sweep_axis['values'].append(v)
-                util.debug(f"Sweep axis: {sweep_axis['key']} : {sweep_axis['values']}")
-                sweep_axis_list.append(sweep_axis)
-                continue
-            if token.startswith('--') or token.startswith('+'):
-                arg_tokens.append(token)
-                continue
-            if self.resolve_target(token, no_recursion=True):
-                if self.sweep_target != "":
-                    self.error(f"Sweep can only take one target, already got {self.sweep_target},"
-                               f"now getting {token}")
-                self.sweep_target = token
-                continue
-            self.error(f"Sweep doesn't know what to do with arg '{token}'")
-        if self.single_command == "":
-            self.error("Didn't get a command after 'sweep'!")
-
-        # now we need to expand the target list
-        util.debug(f"Sweep: command:    '{self.single_command}'")
-        util.debug(f"Sweep: arg_tokens: '{arg_tokens}'")
-        util.debug(f"Sweep: target:     '{self.sweep_target}'")
-
-        # now create the list of jobs, support one axis
-        self.jobs = []
-
-        self.expand_sweep_axis(arg_tokens=arg_tokens, sweep_axis_list=sweep_axis_list)
-        self.run_jobs(command=self.single_command)
-        return tokens
-
-
-    def expand_sweep_axis(
-            self, arg_tokens: list, sweep_axis_list: list, sweep_string: str = ""
-    ) -> None:
-        '''Returns None, appends jobs to self.jobs to be run by CommandParallel.run_jobs(..)'''
-
-        command = self.single_command
-        target = self.sweep_target
-
-        util.debug(f"Entering expand_sweep_axis: command={command}, target={target},",
-                   f"arg_tokens={arg_tokens}, sweep_axis_list={sweep_axis_list}")
-        if len(sweep_axis_list) == 0:
-            # we aren't sweeping anything, create one job
-            snapshot_name = target.replace('../','').replace('/','_') + sweep_string
-            eda_path = get_eda_exec('sweep')
-            self.jobs.append({
-                'name' : snapshot_name,
-                'index' : len(self.jobs),
-                'command_list' : (
-                    [eda_path, command, target, '--job_name', snapshot_name] + arg_tokens
-                )
-            })
-            return
-        sweep_axis = sweep_axis_list[0]
-        for v in sweep_axis['values']:
-            this_arg_tokens = []
-            for a in arg_tokens:
-                a_swept = re.sub(rf'\b{sweep_axis["key"]}\b', f"{v}", a)
-                this_arg_tokens.append(a_swept)
-            next_sweep_axis_list = []
-            if len(sweep_axis_list)>1:
-                next_sweep_axis_list = sweep_axis_list[1:]
-            v_string = f"{v}".replace('.','p')
-            self.expand_sweep_axis(
-                arg_tokens=this_arg_tokens,
-                sweep_axis_list=next_sweep_axis_list,
-                sweep_string = sweep_string + f"_{sweep_axis['key']}_{v_string}"
-            )