opencos-eda 0.2.31__py3-none-any.whl → 0.2.33__py3-none-any.whl

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/commands/sweep.py

@@ -7,7 +7,7 @@ import os
 import re
 
 from opencos import util
-from opencos.eda_base import CommandDesign, CommandParallel, get_eda_exec
+from opencos.eda_base import CommandDesign, CommandParallel, get_eda_exec, which_tool
 
 class CommandSweep(CommandDesign, CommandParallel):
     '''Command handler for: eda sweep ...'''
@@ -19,6 +19,19 @@ class CommandSweep(CommandDesign, CommandParallel):
         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:
@@ -27,22 +40,9 @@ class CommandSweep(CommandDesign, CommandParallel):
             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)
+        '''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(
@@ -55,7 +55,7 @@ class CommandSweep(CommandDesign, CommandParallel):
         - 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
+        # '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 = []
@@ -64,59 +64,49 @@ class CommandSweep(CommandDesign, CommandParallel):
             tokens=tokens,
             parser_arg_list=[
                 'parallel',
+                'sweep',
             ],
             apply_parsed_args=True
         )
 
         self.check_args()
 
-        tokens = unparsed
-
-        self.single_command = self.get_command_from_unparsed_args(tokens=tokens)
+        self.single_command = self.get_command_from_unparsed_args(tokens=unparsed)
 
         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('+'):
+        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)
-                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}'")
@@ -128,7 +118,74 @@ class CommandSweep(CommandDesign, CommandParallel):
 
         self.expand_sweep_axis(arg_tokens=arg_tokens, sweep_axis_list=sweep_axis_list)
         self.run_jobs(command=self.single_command)
-        return tokens
+        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(
@@ -136,35 +193,38 @@ class CommandSweep(CommandDesign, CommandParallel):
     ) -> 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:
+        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 = target.replace('../','').replace('/','_') + sweep_string
+            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, command, target, '--job_name', snapshot_name] + arg_tokens
+                    [eda_path, self.single_command, self.sweep_target,
+                     '--job_name', snapshot_name] + arg_tokens
                 )
             })
             return
-        sweep_axis = sweep_axis_list[0]
+
+        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 = []
-            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:]
+            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=next_sweep_axis_list,
-                sweep_string = sweep_string + f"_{sweep_axis['key']}_{v_string}"
+                sweep_axis_list=sweep_axis_list,
+                sweep_string=this_sweep_string
             )

opencos/deps_helpers.py

@@ -1,6 +1,7 @@
 
 import fnmatch
 import os
+from pathlib import Path
 import sys
 import re
 import shutil
@@ -1149,9 +1150,9 @@ def parse_deps_peakrdl(line : str, target_path : str, target_node : str, enable
 
 
     shell_commands = [
-        [ 'peakrdl', 'regblock', '-o', 'peakrdl/'] + args_list,
+        [ 'peakrdl', 'regblock', '-o', str(Path('peakrdl/'))] + args_list,
         # Edit file to apply some verilator waivers, etc, from peakrdl_cleanup.py:
-        [ 'python3', peakrdl_cleanup_py, f'peakrdl/{top}.sv', f'peakrdl/{top}.sv' ],
+        [ 'python3', peakrdl_cleanup_py, str(Path(f'peakrdl/{top}.sv')), str(Path(f'peakrdl/{top}.sv')) ],
     ]
 
     ret_dict = {

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_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
 
 
@@ -696,8 +691,12 @@ class CommandDesign(Command):
             util.info(f'run_dep_shell_commands {iter=}: {d=}')
             clist = util.ShellCommandList(d['exec_list'])
             # NOTE(drew): shell=True subprocess call, can disable with self.config
-            self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
-                      shell=self.config.get('deps_subprocess_shell', False))
+            #  However, in Windows, we seem to have to run these with shell=False
+            if sys.platform.startswith('win'):
+                self.exec(self.args['work-dir'], clist, shell=False)
+            else:
+                self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
+                          shell=self.config.get('deps_subprocess_shell', False))
 
     def update_file_lists_for_work_dir(self):
         if len(self.dep_work_dir_add_srcs) == 0:
@@ -748,7 +747,7 @@ class CommandDesign(Command):
         to unprocessed-plusargs.
         '''
 
-        # Since this may be coming from a raw CLI/bash argparser, we may have
+        # Since this may be coming from a raw CLI/bash/powershell argparser, we may have
         # args that come from shlex.quote(token), such as:
         #   token = '\'+define+OC_ROOT="/foo/bar/opencos"\''
         # So we strip all outer ' or " on the plusarg:
@@ -1514,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/peakrdl_cleanup.py

@@ -2,7 +2,6 @@
 
 import sys
 import os
-import subprocess
 
 def run(file_in, file_out):
     with open(file_in) as f:

opencos/tests/helpers.py

@@ -11,6 +11,19 @@ from contextlib import redirect_stdout, redirect_stderr
 from opencos import eda, util
 from opencos import deps_schema
 
+def can_run_eda_command(*commands, config: dict) -> bool:
+    '''Returns True if we have any installed tool that can run: eda <command>'''
+    runnable = []
+    for command in list(commands):
+        handler = config['command_handler'].get(command, None)
+        if not handler:
+            return False
+        if handler and getattr(handler, 'CHECK_REQUIRES', []):
+            if not all(isinstance(handler, x) for x in getattr(handler, 'CHECK_REQUIRES', [])):
+                return False
+        runnable.append(True)
+    return runnable and all(runnable)
+
 def chdir_remove_work_dir(startpath, relpath):
     '''Changes dir to startpath/relpath, removes the work directories (eda.work, eda.export*)'''
     os.chdir(os.path.join(startpath, relpath))
@@ -139,41 +152,52 @@ class Helpers:
             print(f'Wrote: {os.path.abspath(logfile)=}')
         return rc
 
-    def is_in_log(self, *want_str, logfile=None):
+    def is_in_log(self, *want_str, logfile=None, windows_path_support=False):
         '''Check if any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         if logfile is None:
             logfile = self.DEFAULT_LOG
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line or \
+                   (windows_path_support and want_str1 in line):
                     return True
         return False
 
-    def get_log_lines_with(self, *want_str, logfile=None):
+    def get_log_lines_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         if logfile is None:
             logfile = self.DEFAULT_LOG
         ret_list = []
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line:
+                    ret_list.append(line)
+                elif windows_path_support and want_str1 in line:
                     ret_list.append(line)
         return ret_list
 
-    def get_log_words_with(self, *want_str, logfile=None):
+    def get_log_words_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of *want_str within a single word
         in the logfile or self.DEFAULT_LOG
         '''
         if logfile is None:
             logfile = self.DEFAULT_LOG
         ret_list = []
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line:
                     for word in line.split():
-                        if want_str in word:
+                        if want_str0 in word:
                             ret_list.append(word)
+                elif windows_path_support and want_str1 in line:
+                    for word in line.split():
+                        if want_str1 in word:
+                            ret_list.append(word)
+
         return ret_list

opencos/tests/test_deps_helpers.py

@@ -6,6 +6,7 @@
 # TODO(drew): for now, ignore long lines and docstrings
 # pylint: disable=line-too-long,missing-function-docstring
 
+from pathlib import Path
 import os
 import pytest
 
@@ -22,15 +23,15 @@ def test_get_all_targets():
 
     targets = deps_helpers.get_all_targets(
         dirs=[
-            '../../lib/tests',
-            '../../lib/rams/tests',
+            str(Path('../../lib/tests')),
+            str(Path('../../lib/rams/tests')),
         ],
-        base_path=THISPATH,
+        base_path=str(Path(THISPATH)),
         filter_str='*test',
     )
     print(f'{targets=}')
-    assert '../../lib/rams/tests/oclib_ram2rw_test' in targets
-    assert '../../lib/tests/oclib_fifo_test' in targets
+    assert str(Path('../../lib/rams/tests/oclib_ram2rw_test')) in targets
+    assert str(Path('../../lib/tests/oclib_fifo_test')) in targets
     for t in targets:
         assert t.endswith('test'), f'target {t} filter did not work *test'
 

opencos/tests/test_eda.py

@@ -24,15 +24,22 @@ from opencos.tests.helpers import eda_wrap, eda_sim_wrap, eda_elab_wrap, \
     Helpers
 
 
-thispath = os.path.dirname(__file__)
+THISPATH = os.path.dirname(__file__)
 
 def chdir_remove_work_dir(relpath):
     '''Changes dir to relpath, removes the work directories (eda.work, eda.export*)'''
-    return helpers.chdir_remove_work_dir(thispath, relpath)
+    return helpers.chdir_remove_work_dir(THISPATH, relpath)
 
 # Figure out what tools the system has available, without calling eda.main(..)
 config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
 
+def can_run_eda_sim() -> bool:
+    '''Returns True if we have any installed tool that can run: eda sim'''
+    return helpers.can_run_eda_command('sim', config=config)
+
+def can_run_eda_elab() -> bool:
+    '''Returns True if we have any installed tool that can run: eda elab'''
+    return helpers.can_run_eda_command('elab', config=config)
 
 @pytest.mark.skipif(
     'verilator' not in tools_loaded and 'vivado' not in tools_loaded,
@@ -112,7 +119,7 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
         print(f'{rc=}')
         assert rc == 0
 
-        os.chdir(os.path.join(thispath, '../../lib/tests/eda.work/oclib_fifo_test.sim'))
+        os.chdir(os.path.join(THISPATH, '../../lib/tests/eda.work/oclib_fifo_test.sim'))
         res = subprocess.run(
             [ './lint_only.sh' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             check=True
@@ -391,18 +398,19 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
 
 
 class TestMissingDepsFileErrorMessages(Helpers):
-    '''Test for missing DEPS.yml file'''
-    DEFAULT_DIR = os.path.join(thispath, 'deps_files', 'no_deps_here', 'empty')
+    '''Test for missing DEPS.yml file, using 'eda export' to avoid tools.'''
+    DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'no_deps_here', 'empty')
     DEFAULT_LOG = 'eda.log'
 
     def test_bad0(self):
         '''Looks for target_bad0, but there is no DEPS file in .'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad0')
+        rc = self.log_it(command_str='export target_bad0')
         assert rc != 0
         assert self.is_in_log(
             'Trying to resolve command-line target=./target_bad0: was not found',
-            'in deps_file=None, possible targets in deps file = []'
+            'in deps_file=None, possible targets in deps file = []',
+            windows_path_support=True
         )
 
 
@@ -413,35 +421,35 @@ class TestDepsResolveErrorMessages(Helpers):
     or other less helpful information to the user. This confirms that file/target/
     linenumber information is printed when available.'''
 
-    DEFAULT_DIR = os.path.join(thispath, 'deps_files', 'error_msgs')
+    DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'error_msgs')
     DEFAULT_LOG = 'eda.log'
 
     # files foo.sv, foo2.sv, target_bad0.sv, and target_bad1.sv exist.
     # files missing*.sv and targets missing* do not exist.
-    # These all run elab targets.
+    # These all "export" targets, to avoid requiring an installed tool (for example, to elab)
 
     def test_good0(self):
         '''Simple test with good target (foo)'''
         self.chdir()
-        rc = self.log_it('elab foo')
+        rc = self.log_it('export foo')
         assert rc == 0
 
     def test_good1(self):
         '''Simple test with good target (foo2)'''
         self.chdir()
-        rc = self.log_it('elab foo2')
+        rc = self.log_it('export foo2')
         assert rc == 0
 
     def test_good2(self):
         '''Simple test with good target (foo + top=foo using deps str)'''
         self.chdir()
-        rc = self.log_it('elab target_good2')
+        rc = self.log_it('export target_good2')
         assert rc == 0
 
     def test_good3(self):
         '''Simple test with good target (foo2 + top=foo2 using deps list)'''
         self.chdir()
-        rc = self.log_it('elab target_good3')
+        rc = self.log_it('export target_good3')
         assert rc == 0
 
     # Bit of a change-detector-test here, but I want to make sure the
@@ -449,133 +457,146 @@ class TestDepsResolveErrorMessages(Helpers):
     def test_bad0(self):
         '''Tests missing file in DEPS target using implicit deps str style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad0')
+        rc = self.log_it(command_str='export target_bad0')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing0.sv (file?): called from ./DEPS.yml::target_bad0::line=20,",
-            "File=missing0.sv not found in directory=."
+            "File=missing0.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad1(self):
         '''Tests missing file in DEPS target using implicit deps list style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad1')
+        rc = self.log_it(command_str='export target_bad1')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing1.sv (file?): called from ./DEPS.yml::target_bad1::line=24,",
-            "File=missing1.sv not found in directory=."
+            "File=missing1.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad2(self):
         '''Tests missing file in DEPS target using deps as str style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad2')
+        rc = self.log_it(command_str='export target_bad2')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing2.sv (file?): called from ./DEPS.yml::target_bad2::line=28,",
-            "File=missing2.sv not found in directory=."
+            "File=missing2.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad3(self):
         '''Tests missing file in DEPS target using deps as list style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad3')
+        rc = self.log_it(command_str='export target_bad3')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing3.sv (file?): called from ./DEPS.yml::target_bad3::line=33,",
-            "File=missing3.sv not found in directory=."
+            "File=missing3.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad4(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), explicit deps str'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad4')
+        rc = self.log_it(command_str='export target_bad4')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target4: called from ./DEPS.yml::target_bad4::line=39,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
         )
 
     def test_bad5(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), explicit deps list'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad5')
+        rc = self.log_it(command_str='export target_bad5')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target5: called from ./DEPS.yml::target_bad5::line=43,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
         )
 
     def test_bad6(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), deps str'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad6')
+        rc = self.log_it(command_str='export target_bad6')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target6: called from ./DEPS.yml::target_bad6::line=47,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
+
         )
 
     def test_bad7(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), deps list'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad7')
+        rc = self.log_it(command_str='export target_bad7')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target7: called from ./DEPS.yml::target_bad7::line=52,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
         )
 
     def test_cmd_line_good0(self):
         '''EDA w/ out DEPS, on file'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo.sv')
+        rc = self.log_it(command_str='export foo.sv')
         assert rc == 0
 
     def test_cmd_line_good1(self):
         '''EDA w/ out DEPS, on two files'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo.sv foo2.sv')
+        rc = self.log_it(command_str='export foo.sv foo2.sv')
         assert rc == 0
 
     def test_cmd_line_bad0(self):
         '''EDA calling a non-existent target in DEPS file'''
         self.chdir()
-        rc = self.log_it(command_str='elab nope_target0')
+        rc = self.log_it(command_str='export nope_target0')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_target0: was not",
-            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'"
+            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'",
+            windows_path_support=True
         )
 
     def test_cmd_line_bad1(self):
         '''EDA calling a non-existent target in DEPS file, with file that exists.'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo.sv nope_target1')
+        rc = self.log_it(command_str='export foo.sv nope_target1')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_target1: was not",
-            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'"
+            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'",
+            windows_path_support=True
         )
 
     def test_cmd_line_bad2(self):
         '''EDA calling a non-existent file w/out DEPS'''
         self.chdir()
-        rc = self.log_it(command_str='elab nope_file0.sv')
+        rc = self.log_it(command_str='export nope_file0.sv')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_file0.sv",
-            "(file?): File=nope_file0.sv not found in directory=."
+            "(file?): File=nope_file0.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_cmd_line_bad3(self):
         '''EDA calling a non-existent file w/out DEPS, and a file that does exist.'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo2.sv nope_file1.sv')
+        rc = self.log_it(command_str='export foo2.sv nope_file1.sv')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_file1.sv",
-            "(file?): File=nope_file1.sv not found in directory=."
+            "(file?): File=nope_file1.sv not found in directory=.",
+            windows_path_support=True
         )
 
 
@@ -599,6 +620,8 @@ class TestsRequiresIVerilog(Helpers):
         print(f'{rc=}')
         assert rc == 0
 
+
+@pytest.mark.skipif(not can_run_eda_sim(), reason='no tool found to handle command: sim')
 class TestDepsReqs:
     '''Tests for 'reqs' in the DEPS files. 'reqs' are requirements, like a .pcap or file
     used by SV $readmemh. They do not fit into normal compilable files (.sv, .v, .vhd[l])
@@ -647,6 +670,7 @@ class TestDepsReqs:
         assert rc != 0
 
 
+@pytest.mark.skipif(not can_run_eda_sim(), reason='no tool found to handle command: sim')
 def test_deps_command_order():
     '''Test for various "commands" within a DEPS target. This test checks that command
     order is preserved in the top-to-bottom deps order, meaning that eda.py has to collect
@@ -684,7 +708,7 @@ def test_deps_command_order():
     # Added check, we redirected to create eda.log earlier to confirm the targets worked,
     # but as a general eda.py check, all shell commands should create their own
     # {target}__shell_0.log file:
-    work_dir = os.path.join(thispath, 'deps_files/command_order', 'eda.work', 'target_test.sim')
+    work_dir = os.path.join(THISPATH, 'deps_files/command_order', 'eda.work', 'target_test.sim')
     with open(os.path.join(work_dir, 'target_echo_hi__shell_0.log'), encoding='utf-8') as f:
         text = ''.join(f.readlines()).strip()
         assert text == 'hi'
@@ -776,7 +800,7 @@ class TestDepsNoFilesTargets(Helpers):
 
 class TestDepsTags(Helpers):
     '''Series of tests for DEPS - target - tags, in ./deps_files/tags_with_tools'''
-    DEFAULT_DIR = os.path.join(thispath, 'deps_files', 'tags_with_tools')
+    DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'tags_with_tools')
     DEFAULT_LOG = 'eda.log'
 
     @pytest.mark.skipif('verilator' not in tools_loaded, reason="requires verilator")

opencos/tests/test_tools.py

@@ -3,6 +3,7 @@
 # pylint: disable=R0801 # (similar lines in 2+ files)
 
 import os
+import sys
 import pytest
 
 from opencos import eda, util, eda_tool_helper, eda_base
@@ -29,7 +30,15 @@ def test_tools_loaded():
     '''
     assert config
     assert len(config.keys()) > 0
-    assert len(tools_loaded) > 0
+
+    # It's possible we're running in some container or install that has no tools, for example,
+    # Windows.
+    if sys.platform.startswith('win') and \
+       not helpers.can_run_eda_command('elab', 'sim', config=config):
+        # Windows, not handlers for elab or sim:
+        pass
+    else:
+        assert len(tools_loaded) > 0
 
     def version_checker(
             obj: eda_base.Tool, chk_str: str
@@ -95,7 +104,7 @@ def test_err_fatal(command, tool, target, sim_expect_pass):
 
 
 @pytest.mark.skipif('vivado' not in tools_loaded, reason="requires vivado")
-def test_vivado_xilinx_arg():
+def test_vivado_tool_defines():
     '''This test attempts to confirm that the following class inheritance works:
 
     Command <- CommandDesign <- CommandSim <- CommandSimVivado <- CommandElabVivado

opencos/util.py

@@ -582,7 +582,8 @@ def write_shell_command_file(dirpath : str, filename : str, command_lists : list
     assert type(command_lists) is list, f'{command_lists=}'
     fullpath = os.path.join(dirpath, filename)
     with open(fullpath, 'w') as f:
-        if not bash_path: bash_path = "/bin/bash" # we may not get far, but we'll try
+        if not bash_path:
+            bash_path = "/bin/bash" # we may not get far, but we'll try
         f.write('#!' + bash_path + '\n\n')
         for obj in command_lists:
             assert isinstance(obj, list), f'{obj=} (obj must be list/ShellCommandList) {command_lists=}'

{opencos_eda-0.2.31.dist-info → opencos_eda-0.2.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.31
+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.31.dist-info → opencos_eda-0.2.33.dist-info}/RECORD

@@ -1,10 +1,10 @@
 opencos/__init__.py,sha256=ZQ7aOCbP0jkIMYGdVrb-mkZX3rnvaK8epBkmp506tXU,85
 opencos/_version.py,sha256=qN7iBoOv-v4tEZz-Pu9sVUJwefshJOsgdaddn8HcHio,510
 opencos/_waves_pkg.sv,sha256=1lbhQOVGc3t_R8czYjP40hssP0I3FlZOpHTkI7yKFbI,1251
-opencos/deps_helpers.py,sha256=5Ewgt5Eo79CldIx5NqAGf6mmAiLXjyhkJjpqTQo5Lg4,56653
-opencos/deps_schema.py,sha256=WXgYpFSKZgpq6OAtCKP3006O_isa5qXOfJYlqARhIcQ,13785
+opencos/deps_helpers.py,sha256=zM9n6k61jaW9SE7VTtfMNaF8oA9UFloEcI685NLOpIQ,56711
+opencos/deps_schema.py,sha256=MhytzXwp071F14RwxqHt78ak8Qruoe4FeK5XSzkO2f0,14658
 opencos/eda.py,sha256=NCsSAnWANumzP2EzlsT-TvGUEuY8ONpHo-cvTcWC2wM,21261
-opencos/eda_base.py,sha256=O8mYRvnP2tPY3Rbm816Ce0cNTYRjIdJXnqJxk7Sixds,75050
+opencos/eda_base.py,sha256=Fi21IIKvYIzyj_vQtaqPwrUXDaszfIixoB80-TQMM2k,77455
 opencos/eda_config.py,sha256=CXfFVW4QOtP1gpMcX8JhCe93_aibcdbGoS7RAiYQnOs,8561
 opencos/eda_config_defaults.yml,sha256=SqQEOA8cn4ASM2oHnBiEtb7s-RNMvtDYuJAoqB1jE2w,9326
 opencos/eda_config_max_verilator_waivers.yml,sha256=lTAU4IOEbUWVlPzuer1YYhIyxpPINeA4EJqcRIT-Ymk,840
@@ -18,33 +18,33 @@ opencos/files.py,sha256=IB-hTRrVQx884GNqdJX1V1ikSRUS1Vwu-B3yX0AN6FI,1495
 opencos/names.py,sha256=LMhAE5UH5LEy4zqHp3rOe6tP26i_Dka6JOJzKMo_bkg,1201
 opencos/oc_cli.py,sha256=kj2OXvgxli2WPj4MQ4zTBb36eFtsP2gsqDdeNeWGL4E,132108
 opencos/pcie.py,sha256=VUJljaZJYgScAAx5yn7F6GoA8K9eTcw24otYZbkMpYs,3035
-opencos/peakrdl_cleanup.py,sha256=hSEmIl_Mud9ZnjJmQg-pdMtzsI5RkWL8ASjKHFhiWtI,504
+opencos/peakrdl_cleanup.py,sha256=vLhSOVs6cEzsi_PwAP4pSXu5_ZMZjDvfK_WmHDLbDac,486
 opencos/seed.py,sha256=8TA2uXhBuT_lOaQdAKqdReYvfBWi_KuyQCFJzA2rOVM,549
-opencos/util.py,sha256=0ddstrUlMv377Uif-jrfkTaWqmontiKbv-Dcy4Ub2E0,27849
+opencos/util.py,sha256=3rADW0tUzq69wdHsa2GB060N1jCAK2Dk0NLx6N6BMcc,27861
 opencos/commands/__init__.py,sha256=cHermtb27ZOUurW1UIGarQIJihH1oJvpFWwUbk6q2i0,858
 opencos/commands/build.py,sha256=jI5ul53qfwn6X-yfSdSQIcLBhGtzZUk7r_wKBBmKJI0,1425
 opencos/commands/elab.py,sha256=m6Gk03wSzX8UkcmReooK7turF7LpqO0IcdOZwJ8XiyI,1596
 opencos/commands/export.py,sha256=uGDI5_lUhyNB54gFjm9cWv9g_3waEOJN4wOC01oFlCY,3535
 opencos/commands/flist.py,sha256=rylcisH3X6UZGQY8WkSGHHIYWKi6o-JwtITz7gflsbY,8460
-opencos/commands/multi.py,sha256=I0Bj1WkbR27AWfZpKvphOmLMBIin_8wrlWqOEA85bEA,27220
+opencos/commands/multi.py,sha256=__UF5If4WIY_9044gcGEQiU8MTGPro-q3kzQ4v0PMdI,26283
 opencos/commands/open.py,sha256=unrpGckzg0FE5W3oARq8x0jX7hhV_uM9Oh5FgISHFAg,724
 opencos/commands/proj.py,sha256=MdHTOtQYG93_gT97dWuSyAgUxX2vi9FRhL0dtc-rM98,1096
 opencos/commands/sim.py,sha256=phATz_wR0BAH6B_IJ4zyzg_Hptp5hSEOe_-9NLaL_bY,14058
-opencos/commands/sweep.py,sha256=VnkViqU452kbeUSFJOki6Cr89nisb5ER7efLhEQZfDc,6869
+opencos/commands/sweep.py,sha256=L4AYF3vQHR-fi0871f1CwrD0y4tydrsNpWSDjVf1xIA,8719
 opencos/commands/synth.py,sha256=quB-HWS4LKYTiFBHiYarQi4pMnRmt12wQTZpi14VvlE,4355
 opencos/commands/upload.py,sha256=nlb4nlxrDCQPcabEmH3nP19g4PFILDqFDab4LwJ95Z4,796
 opencos/commands/waves.py,sha256=SRfjfsqhuszXHylQrgqYiUT3a5CQs9doxJQzuV4Ae0w,7055
 opencos/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/tests/custom_config.yml,sha256=TRoVM9ZFKPOA_8JmlpzaMhnGO1txmaD14N_8P1oqzew,257
-opencos/tests/helpers.py,sha256=-26Chc38kNjXBRJ1ex1YVicnzlsb1Gr9EGHSt3WY-Y4,7028
+opencos/tests/helpers.py,sha256=M_XwM1vQmcrVEgfvpL7C23VPjiFhPpsCqhAH5ZZqAT4,8211
 opencos/tests/test_build.py,sha256=FQAxOpLVQShAHD_L5rqJctPeSAoqoOCNFI0RXflLuY0,387
-opencos/tests/test_deps_helpers.py,sha256=3WUrS7TnhJfeSFBqLQJ_YZPxB17yrVKxQeAQX78sKpw,5848
+opencos/tests/test_deps_helpers.py,sha256=_nJSgLN6WVlMKqu6sCr29gjQyN3Jj-dVk8Ac64ygpJs,5928
 opencos/tests/test_deps_schema.py,sha256=mWTWI4wriGXC8UAnaeq_MIvWJOvf08-fPUqUgELptQ4,896
-opencos/tests/test_eda.py,sha256=PBvB3VKOWwgWDDn37wa_b2qMWaAl8buIvvgxHjJmYVU,36625
+opencos/tests/test_eda.py,sha256=HCUGCg9yVILIIyyey2XArllgtBV5XHeVVnL5AGglO7I,37786
 opencos/tests/test_eda_elab.py,sha256=75bJpOaoO8rn1FXFxiE4KSu5FdjZP1IbW6SyTCjM_ao,2553
 opencos/tests/test_eda_synth.py,sha256=C_1LzblTuK_lHFv_Hh8v3DKUN4hGfxoChYR77GricX4,2871
 opencos/tests/test_oc_cli.py,sha256=-ZmwVX_CPBXCGT9hXIBEr_XUSIGG2eky89YpSJIbRAg,731
-opencos/tests/test_tools.py,sha256=5enJM_-E7KnKjV9-CIzTV7Al07sx2eisKsGS_8fKalg,4907
+opencos/tests/test_tools.py,sha256=LwOEaFDZpo5-a4Vs4kQUYL6dbeE_IrKvEcyY_p-o5bg,5221
 opencos/tests/deps_files/command_order/DEPS.yml,sha256=vloOzWZ5qU3yGNFaDlrAJdEzYxK6qf8gfac3zqF-0FI,438
 opencos/tests/deps_files/error_msgs/DEPS.yml,sha256=fYvHouIscOlr8V28bqx9SoxRBpDBLX4AG-AkVXh8qbo,717
 opencos/tests/deps_files/iverilog_test/DEPS.yml,sha256=vDylEuLt642lhRSvOr3F5ziB5lhPSwkaUGN4_mWJw-c,40
@@ -66,10 +66,10 @@ opencos/tools/tabbycad_yosys.py,sha256=h9kkAi479cZzYfb4R9WBNY_JmR6BgVFj4s3VShnGp
 opencos/tools/verilator.py,sha256=NNn9xF-YWFE6B8a9BNeuK-10xNCXPzACqyfKdwuqKTY,17996
 opencos/tools/vivado.py,sha256=cL5IZdudqquddvZqHQGDVmaHSxgBZsMUmAq18q8AgoM,39134
 opencos/tools/yosys.py,sha256=Nov3zKyliZ6rHwMbH4f8XEkoo9H66T2-MN-KNQTjWFk,3530
-opencos_eda-0.2.31.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-opencos_eda-0.2.31.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
-opencos_eda-0.2.31.dist-info/METADATA,sha256=pUGvgUFre5nRTgzKjpbHFbPBbmFcpjti8Rs3XOQEj5g,604
-opencos_eda-0.2.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opencos_eda-0.2.31.dist-info/entry_points.txt,sha256=777csZnOi0t9uC8lrdTchl9_Lu11t0UTo9xIKLNabNE,176
-opencos_eda-0.2.31.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
-opencos_eda-0.2.31.dist-info/RECORD,,
+opencos_eda-0.2.33.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+opencos_eda-0.2.33.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
+opencos_eda-0.2.33.dist-info/METADATA,sha256=d20V-XOWBX4u8Rqmmr5b5TgTZOClrFYDBVB8_b_TjmA,604
+opencos_eda-0.2.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opencos_eda-0.2.33.dist-info/entry_points.txt,sha256=777csZnOi0t9uC8lrdTchl9_Lu11t0UTo9xIKLNabNE,176
+opencos_eda-0.2.33.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
+opencos_eda-0.2.33.dist-info/RECORD,,