opencos-eda 0.2.44__tar.gz → 0.2.46__tar.gz

{opencos_eda-0.2.44/opencos_eda.egg-info → opencos_eda-0.2.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.44
+Version: 0.2.46
 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.44 → opencos_eda-0.2.46}/opencos/commands/__init__.py

@@ -17,7 +17,9 @@ from .sweep import CommandSweep
 from .synth import CommandSynth
 from .upload import CommandUpload
 from .waves import CommandWaves
+from .shell import CommandShell
 from .targets import CommandTargets
+from .lec import CommandLec
 
 __all__ = [
     'CommandBuild',
@@ -33,5 +35,7 @@ __all__ = [
     'CommandToolsMulti',
     'CommandUpload',
     'CommandWaves',
+    'CommandShell',
     'CommandTargets',
+    'CommandLec',
 ]

opencos_eda-0.2.46/opencos/commands/lec.py

@@ -0,0 +1,103 @@
+'''opencos.commands.lec - Base class command handler for: eda lec ...
+
+Intended to be overriden by Tool based classes (such as CommandLecYosys, etc)
+'''
+
+# Note - similar code waiver, tricky to eliminate it with inheritance when
+# calling reusable methods.
+# pylint: disable=R0801
+
+import os
+
+from opencos import eda_extract_targets
+from opencos.eda_base import CommandDesign, Tool
+
+
+class CommandLec(CommandDesign):
+    '''Base class command handler for: eda lec ...'''
+
+    CHECK_REQUIRES = [Tool]
+    error_on_no_files_or_targets = False
+    error_on_missing_top = False # we'll override it.
+
+    command_name = 'lec'
+
+    def __init__(self, config: dict):
+        CommandDesign.__init__(self, config=config)
+        self.args.update({
+            'designs': [],
+            'synth': True,
+        })
+        self.args_help.update({
+            'designs': (
+                'Set the two LEC comparison designs: --designs=<target1> --designs=<target2>,'
+                ' use this arg twice'
+            ),
+            'synth': 'run synthesis on the two designs prior to running LEC',
+        })
+
+        self.synth_design_verilog_fpaths = ['', '']
+
+
+    def do_it(self) -> None:
+        '''Common do_it() method that child classes can use prior to customization'''
+
+        # set_tool_defines() is from class Tool. Since that is not inherited yet, but
+        # should be by any handlers, check on the existence of set_tool_defines, and
+        # error if not present.
+        if not all(isinstance(self, x) for x in self.CHECK_REQUIRES):
+            self.error('CommandLec.do_it() requires a Tool to be in parent classes, but none is.',
+                       f'{self.CHECK_REQUIRES=}')
+            return
+
+        # add defines for this job from Tool class if present
+        self.command_safe_set_tool_defines() # (Command.command_safe_set_tool_defines)
+
+        # dump our config to work-dir for debug
+        self.write_eda_config_and_args()
+
+        # Note - we do not support --export in LEC.
+        # Derived classes can do the rest, can call CommandLec.do_it(self) as a first step.
+
+
+    def process_tokens(self, tokens: list, process_all: bool = True,
+                       pwd: str = os.getcwd()) -> list:
+        unparsed = CommandDesign.process_tokens(
+            self, tokens=tokens, process_all=process_all, pwd=pwd
+        )
+
+        if self.status_any_error():
+            return unparsed
+
+        # add defines for this job type
+        if not self.args['top']:
+            self.args['top'] = 'eda.lec'
+
+        # we require there to be two --designs set.
+        if not self.args['designs'] and len(self.args['designs']) != 2:
+            self.error('Requires two designs via --designs=<target1> --designs=<target2>',
+                       f'designs={self.args["designs"]}')
+            return []
+
+        # Before we do anything else, make sure the two designs actually exist.
+        for design in self.args['designs']:
+            # maybe it's a file?
+            if os.path.isfile(design):
+                pass
+            elif design in eda_extract_targets.get_targets(partial_paths=[design], base_path=pwd):
+                pass
+            else:
+                self.error(f'--designs={design}, value is not a file or target')
+
+        # create our work dir
+        self.create_work_dir()
+        self.run_dep_commands()
+        self.do_it()
+        return unparsed
+
+
+    def get_synth_result_fpath(self, target: str) -> str:
+        '''Derived classes must define. Given a synth target for one of the two
+
+        designs to compare, return the location of the synthesis file'''
+        raise NotImplementedError

opencos_eda-0.2.46/opencos/commands/shell.py

@@ -0,0 +1,202 @@
+'''opencos.commands.shell - Base class command handler for: eda shell ...
+
+Not intended to be overriden by Tool based classes.'''
+
+# Note - tricky to eliminate it with inheritance when calling reusable methods.
+# pylint: disable=R0801
+
+# TODO(drew): clean up CommandShell.check_logs_for_errors and CommandShell.run_commands_check_logs
+#   These also share a lot with CommandSim.* methods, so consider refactoring to share code,
+#   for example, CommandShell.do_export could move to CommandDesign, and derived classes
+#   set the allow-listed args to pass to export.
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+
+import os
+
+from opencos import util, export_helper
+from opencos.eda_base import CommandDesign
+
+
+class CommandShell(CommandDesign):
+    '''Base class command handler for: eda sim ...'''
+
+    command_name = 'shell'
+
+    def __init__(self, config: dict):
+        CommandDesign.__init__(self, config=config)
+        self.args.update({
+            'pass-pattern': "",
+            'log-bad-strings': [],
+            'log-must-strings': [],
+        })
+        self.args_help.update({
+            'log-bad-strings': (
+                'strings that if present in the log will cause an `eda shell` error'
+            ),
+            'log-must-strings': (
+                'strings that are required by the log to not-fail the `eda shell` call'
+            ),
+            'pass-pattern': (
+                'Additional string required to pass the `eda shell` call, appends to'
+                ' log-must-strings'
+            ),
+        })
+
+    def process_tokens(self, tokens: list, process_all: bool = True,
+                       pwd: str = os.getcwd()) -> list:
+        unparsed = CommandDesign.process_tokens(
+            self, tokens=tokens, process_all=process_all, pwd=pwd
+        )
+
+        if self.status_any_error():
+            return unparsed
+
+        if self.args['top']:
+            # create our work dir
+            self.create_work_dir()
+            self.run_dep_commands()
+            self.do_it()
+        return unparsed
+
+
+    def run_commands_check_logs( # pylint: disable=dangerous-default-value
+            self, commands: list , check_logs: bool = True, log_filename=None,
+            bad_strings: list = [],
+            must_strings: list = [],
+            use_bad_strings: bool = True, use_must_strings: bool = True
+    ) -> None:
+        '''Returns None, runs all commands (each element is a list) and checks logs
+
+        for bad-strings and must-strings (args or class member vars)
+        '''
+
+        for obj in commands:
+
+            assert isinstance(obj, list), \
+                (f'{self.target=} command {obj=} is not a list or util.ShellCommandList,'
+                 ' not going to run it.')
+
+            clist = list(obj).copy()
+            tee_fpath = getattr(obj, 'tee_fpath', None)
+
+            util.debug(f'run_commands_check_logs: {clist=}, {tee_fpath=}')
+
+            log_fname = None
+            if tee_fpath:
+                log_fname = tee_fpath
+            if log_filename:
+                log_fname = log_filename
+
+            self.exec(work_dir=self.args['work-dir'], command_list=clist, tee_fpath=tee_fpath)
+
+            if check_logs and log_fname:
+                self.check_logs_for_errors(
+                    filename=log_fname, bad_strings=bad_strings, must_strings=must_strings,
+                    use_bad_strings=use_bad_strings, use_must_strings=use_must_strings
+                )
+
+
+    def do_export(self) -> None:
+        '''CommandShell helper for handling args --export*
+
+        We allow commands such as: eda shell --export <target>
+        '''
+
+        out_dir = os.path.join(self.args['work-dir'], 'export')
+
+        target = self.target
+        if not target:
+            target = 'test'
+
+        export_obj = export_helper.ExportHelper(
+            cmd_design_obj=self,
+            eda_command=self.command_name,
+            out_dir=out_dir,
+            # Note this may not be the correct target for debug infomation,
+            # so we'll only have the first one.
+            target=target
+        )
+
+        # Set things in the exported: DEPS.yml
+        tool = self.args.get('tool', None)
+        # Certain args are allow-listed here
+        deps_file_args = []
+        for a in self.get_command_line_args():
+            if any(a.startswith(x) for x in [
+                    '--log-must',
+                    '--log-bad',
+                    '--pass-pattern']):
+                deps_file_args.append(a)
+
+        export_obj.run(
+            deps_file_args=deps_file_args,
+            export_json_eda_config={
+                'tool': tool,
+            }
+        )
+
+        if self.args['export-run']:
+
+            # remove the '--export' named args, we don't want those.
+            args_no_export = self.get_command_line_args(remove_args_startswith=['export'])
+
+            command_list = ['eda', self.command_name] + args_no_export + [target]
+
+            util.info(f'export-run: from {export_obj.out_dir=}: {command_list=}')
+            self.exec(
+                work_dir=export_obj.out_dir,
+                command_list=command_list,
+            )
+
+
+    def do_it(self) -> None:
+        self.write_eda_config_and_args()
+
+        if self.is_export_enabled():
+            # If we're exporting the target, we do NOT run the test here
+            # (do_export() may run the test in a separate process and
+            # from the out_dir if --export-run was set)
+            self.do_export()
+
+
+    def check_logs_for_errors( # pylint: disable=dangerous-default-value
+            self, filename: str,
+            bad_strings: list = [], must_strings: list = [],
+            use_bad_strings: bool = True, use_must_strings: bool = True
+    ) -> None:
+        '''Returns None, checks logs using args bad_strings, must_strings,
+
+        and internals self.args["log-[bad|must]-strings"] (lists).
+        '''
+
+        _bad_strings = bad_strings
+        _must_strings = must_strings
+        # append, if not they would 'replace' the args values:
+        if use_bad_strings:
+            _bad_strings = bad_strings + self.args.get('log-bad-strings', [])
+        if use_must_strings:
+            _must_strings = must_strings + self.args.get('log-must-strings', [])
+
+        if self.args['pass-pattern'] != "":
+            _must_strings.append(self.args['pass-pattern'])
+
+        if len(_bad_strings) > 0 or len(_must_strings) > 0:
+            hit_bad_string = False
+            hit_must_string_dict = dict.fromkeys(_must_strings)
+            fname = os.path.join(self.args['work-dir'], filename)
+            with open(fname, 'r', encoding='utf-8') as f:
+                for lineno, line in enumerate(f):
+                    if any(must_str in line for must_str in _must_strings):
+                        for k, _ in hit_must_string_dict.items():
+                            if k in line:
+                                hit_must_string_dict[k] = True
+                    if any(bad_str in line for bad_str in _bad_strings):
+                        hit_bad_string = True
+                        self.error(f"log {fname}:{lineno} contains one of {_bad_strings=}")
+
+            if hit_bad_string:
+                self.status += 1
+            if any(x is None for x in hit_must_string_dict.values()):
+                self.error(f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
+                           f" {hit_must_string_dict=}")
+                self.status += 1

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/commands/sim.py

@@ -306,7 +306,7 @@ class CommandSim(CommandDesign):
             if hit_bad_string:
                 self.status += 1
             if any(x is None for x in hit_must_string_dict.values()):
-                self.error(f"Didn't get all passing patternsin log {fname}: {_must_strings=}",
+                self.error(f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
                            f" {hit_must_string_dict=}")
                 self.status += 1
 

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/deps_helpers.py

@@ -68,6 +68,7 @@ class Defaults:
         'shell',
         'work-dir-add-srcs', 'work-dir-add-sources',
         'peakrdl',
+        'run-from-work-dir',
         'var-subst-args',
         'var-subst-os-env',
         'tee',
@@ -387,20 +388,20 @@ def path_substitutions_relative_to_work_dir(exec_list : list, info_str : str, ta
 
     # Look for path substitutions, b/c we later "work" in self.args['work-dir'], but
     # files should be relative to our target_path.
-    for iter,word in enumerate(exec_list):
+    for i,word in enumerate(exec_list):
         m = re.search(r'(\.+\/+[^"\;\:\|\<\>\*]*)$', word)
         if m:
             # ./, ../, file=./../whatever  It might be a filepath.
             # [^"\;\:\|\<\>\*] is looking for non-path like characters, so we dont' have a trailing
             #  " : ; < > |
-            # try and see if this file exists. Note that files in the self.args['work-dir'] don't
+            # try and see if this file or dir exists. Note that files in the self.args['work-dir'] don't
             # need this, and we can't assume dir levels in the work-dir.
             try:
                 try_path = os.path.abspath(os.path.join(os.path.abspath(target_path), m.group(1)))
-                if os.path.isfile(try_path):
+                if os.path.isfile(try_path) or os.path.isdir(try_path):
                     # make the substitution
-                    exec_list[iter] = word.replace(m.group(1), try_path)
-                    debug(f'path substitution {info_str=} {target_path=}: replaced - {word=} is now ={exec_list[iter]}')
+                    exec_list[i] = word.replace(m.group(1), try_path)
+                    debug(f'path substitution {info_str=} {target_path=}: replaced - {word=} is now ={exec_list[i]}')
             except:
                 pass
 
@@ -1064,6 +1065,7 @@ def parse_deps_shell_str(line : str, target_path : str, target_node : str, enabl
 
     d = {'target_path': os.path.abspath(target_path),
          'target_node': target_node,
+         'run_from_work_dir': True,
          'exec_list': exec_list,
          }
     return d
@@ -1137,12 +1139,12 @@ def parse_deps_peakrdl(line : str, target_path : str, target_node : str, enable
 
     sv_files = list()
     top = ''
-    for iter,str_value in enumerate(args_list):
+    for i,str_value in enumerate(args_list):
         if '--top=' in str_value:
             _, top = str_value.split('=')
         elif '--top' in str_value:
-            if iter + 1 < len(args_list):
-                top = args_list[iter + 1]
+            if i + 1 < len(args_list):
+                top = args_list[i + 1]
 
     for str_item in args_list:
         if str_item[-4:] == '.rdl':
@@ -1235,14 +1237,14 @@ def deps_commands_handler(config: dict, eda_args: dict,
             var_subst_dict = eda_args
 
         tee_fpath = command.get('tee', None)
+        run_from_work_dir = command.get('run-from-work-dir', True) # for shell, default True
 
         for key,item in command.items():
 
             # skip the var-subst-* keys, since these types are bools
-            if key.startswith('var-subst'):
-                continue
-
-            if key.startswith('tee'):
+            if key.startswith('var-subst') or \
+               key.startswith('tee') or \
+               key.startswith('run-from-work-dir'):
                 continue
 
             # Optional variable substituion in commands
@@ -1262,6 +1264,7 @@ def deps_commands_handler(config: dict, eda_args: dict,
                 # list item in ret_dict['exec_list'], and make it a util.ShellCommandList.
                 if tee_fpath:
                     ret_dict['exec_list'] = ShellCommandList(ret_dict['exec_list'], tee_fpath=tee_fpath)
+                ret_dict['run_from_work_dir'] = run_from_work_dir
                 assert ret_dict, f'shell command failed in {dep=} {target_node=} in {deps_file=}'
                 shell_commands_list.append(ret_dict) # process this later, append to our to-be-returned tuple
 

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/deps_schema.py

@@ -69,6 +69,8 @@ my_target_name:
       - shell:                       <---- string for shell command to be run
         var-subst-args:              <---- bool, perform var substitution using args
         var-subst-os-env:            <---- bool, perform var substitution using os.environ
+        run-from-work-dir:           <---- bool, default True, if False runs from target dir
+                                           instead of work-dir.
         tee:                         <---- string, filename to write logs to
       - work-dir-add-sources:        <---- work-dir-add-sources, optional list (or string)
         - some_file_gen_from_sh.sv   <---- string filename that we created with sh command
@@ -150,6 +152,7 @@ DEPS_COMMANDS_LIST = [
         Optional('shell'): str,
         Optional('var-subst-args'): bool,
         Optional('var-subst-os-env'): bool,
+        Optional('run-from-work-dir'): bool,
         Optional('tee'): Or(str, type(None)),
     },
     {

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/eda.py

@@ -87,6 +87,8 @@ Where <command> is one of:
     upload       - Uploads a finished design into hardware
     open         - Opens a project
     export       - Export files related to a target, tool independent
+    shell        - Runs only commands for DEPS target (like sim or elab, but stops prior to tool)
+    targets      - list all possible targets given glob path.
     help         - This help (without args), or i.e. "eda help sim" for specific help
 
 And <files|targets, ...> is one or more source file or DEPS markup file target,

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/eda_base.py

@@ -302,6 +302,8 @@ class Command:
 
     def exec(self, work_dir, command_list, background=False, stop_on_error=True,
              quiet=False, tee_fpath=None, shell=False):
+        if not tee_fpath and getattr(command_list, 'tee_fpath', None):
+            tee_fpath = getattr(command_list, 'tee_fpath', '')
         if not quiet:
             util.info(f"exec: {' '.join(command_list)} (in {work_dir}, {tee_fpath=})")
         original_cwd = util.getcwd()
@@ -714,8 +716,9 @@ class CommandDesign(Command):
 
         log_fnames_count = {} # count per target_node.
 
-        for iter, d in enumerate(self.dep_shell_commands):
+        for i, d in enumerate(self.dep_shell_commands):
             clist = util.ShellCommandList(d['exec_list'])
+            run_from_work_dir = d['run_from_work_dir'] # default True
             log = clist.tee_fpath
             target_node = d["target_node"]
             if clist.tee_fpath is None:
@@ -727,24 +730,38 @@ class CommandDesign(Command):
             all_cmds_lists += [
                 [], # blank line
                 # comment, where it came from, log to {node}__shell_{lognum}.log (or tee name from DEPS.yml)
-                [f'# command {iter}: target: {d["target_path"]} : {target_node} --> {log}'],
-                # actual command (list or util.ShellCommandList)
-                clist,
+                [f'# command {i}: target: {d["target_path"]} : {target_node} --> {log}'],
             ]
+            if not run_from_work_dir:
+                all_cmds_lists.append([f'cd {d["target_path"]}'])
+
+            # actual command (list or util.ShellCommandList)
+            all_cmds_lists.append(clist)
+
+            if not run_from_work_dir:
+                all_cmds_lists.append([f'cd {os.path.abspath(self.args["work-dir"])}'])
+
             d['exec_list'] = clist # update to tee_fpath is set.
 
         util.write_shell_command_file(dirpath=self.args['work-dir'], filename='pre_compile_dep_shell_commands.sh',
                                       command_lists=all_cmds_lists)
 
-        for iter,d in enumerate(self.dep_shell_commands):
-            util.info(f'run_dep_shell_commands {iter=}: {d=}')
+        for i,d in enumerate(self.dep_shell_commands):
+            util.info(f'run_dep_shell_commands {i=}: {d=}')
             clist = util.ShellCommandList(d['exec_list'])
+            tee_fpath=clist.tee_fpath
+            if d['run_from_work_dir']:
+                run_from_dir = self.args['work-dir']
+            else:
+                # Run from the target's directory (not the `eda` caller $PWD)
+                run_from_dir = d["target_path"]
+                tee_fpath = os.path.abspath(os.path.join(self.args['work-dir'], tee_fpath))
             # NOTE(drew): shell=True subprocess call, can disable with self.config
-            #  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)
+                # for Windows, we run shell=True otherwise most built-in cmd.exe calls won't work.
+                self.exec(run_from_dir, clist, tee_fpath=tee_fpath, shell=True)
             else:
-                self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
+                self.exec(run_from_dir, clist, tee_fpath=tee_fpath,
                           shell=self.config.get('deps_subprocess_shell', False))
 
     def update_file_lists_for_work_dir(self):
@@ -764,10 +781,10 @@ class CommandDesign(Command):
         my_file_lists_list = [self.files_v, self.files_sv, self.files_vhd, self.files_cpp,
                               self.files_sdc]
         for my_file_list in my_file_lists_list:
-            for iter,value in enumerate(my_file_list):
+            for i,value in enumerate(my_file_list):
                 if value and type(value) is str and value.startswith(self._work_dir_add_srcs_path_string):
                     new_value = os.path.join(work_dir_abspath, value[_work_dir_add_srcs_path_string_len :])
-                    my_file_list[iter] = new_value
+                    my_file_list[i] = new_value
                     util.debug(f"file lists: replaced {value} with {new_value}")
 
     def update_non_source_files_in_work_dir(self):
@@ -1160,7 +1177,7 @@ class CommandDesign(Command):
             else:
                 target_name = os.path.join(".", token) # prepend ./so that we always have a <path>/<file>
 
-            util.debug(f'Calling self.resolve_target on {target_name=}')
+            util.debug(f'Calling self.resolve_target on {target_name=} ({token=})')
             if self.resolve_target(target_name, caller_info=caller_info):
                 if not self.args['top']:
                     # last cmd line arg was a target that we'll likely use for inferred top.
@@ -1573,10 +1590,10 @@ class CommandParallel(Command):
         else:
             util.info(f"Parallel: <No jobs found>")
         # Make sure all jobs have a set status:
-        for iter,rc in enumerate(self.jobs_status):
+        for i,rc in enumerate(self.jobs_status):
             if rc is None or type(rc) != int:
-                self.error(f'job {iter=} {rc=} did not return a proper return code')
-                jobs_status[iter] = 1
+                self.error(f'job {i=} {rc=} did not return a proper return code')
+                jobs_status[i] = 1
 
         # if self.status > 0, then keep it non-zero, else set it if we still have running jobs.
         if self.status == 0:

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/eda_config_defaults.yml

@@ -9,19 +9,21 @@ DEFAULT_HANDLERS:
   sim         : opencos.commands.CommandSim
   elab        : opencos.commands.CommandElab
   synth       : opencos.commands.CommandSynth
-  flist       : opencos.commands.CommandFList
   proj        : opencos.commands.CommandProj
   build       : opencos.commands.CommandBuild
   upload      : opencos.commands.CommandUpload
   open        : opencos.commands.CommandOpen
+  lec         : opencos.commands.CommandLec
   # These commands don't necessarily require a tool
   multi       : opencos.commands.CommandMulti
   tools-multi : opencos.commands.CommandToolsMulti
   sweep       : opencos.commands.CommandSweep
+  flist       : opencos.commands.CommandFList
   # These commands (waves, export, targets) do not require a tool, or
   # will self determine the tool:
   waves       : opencos.commands.CommandWaves
   export      : opencos.commands.CommandExport
+  shell       : opencos.commands.CommandShell
   targets     : opencos.commands.CommandTargets
 
 
@@ -60,6 +62,7 @@ file_extensions:
     - .vhdl
   cpp:
     - .cpp
+    - .cc
   synth_constraints:
     - .sdc
     - .xdc
@@ -337,6 +340,15 @@ auto_tools_order:
         flist:  opencos.tools.vivado.CommandFListVivado
         build:  opencos.tools.vivado.CommandBuildVivado
 
+    slang_yosys:
+      exe: yosys
+      requires_cmd:
+        - yosys -m slang
+      handlers:
+        elab:  opencos.tools.slang_yosys.CommandElabSlangYosys
+        synth: opencos.tools.slang_yosys.CommandSynthSlangYosys
+        lec:   opencos.tools.slang_yosys.CommandLecSlangYosys
+
     tabbycad_yosys:
       exe: yosys
       requires_env:
@@ -354,13 +366,13 @@ auto_tools_order:
         elab:  opencos.tools.invio_yosys.CommandElabInvioYosys
         synth: opencos.tools.invio_yosys.CommandSynthInvioYosys
 
-    slang_yosys:
+    yosys:
       exe: yosys
       requires_cmd:
-        - yosys -m slang
+        - yosys
       handlers:
-        elab:  opencos.tools.slang_yosys.CommandElabSlangYosys
-        synth: opencos.tools.slang_yosys.CommandSynthSlangYosys
+        synth: opencos.tools.slang_yosys.CommonSynthYosys
+        lec:   opencos.tools.slang_yosys.CommandLecYosys
 
     questa:
       exe: qrun

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/eda_extract_targets.py

@@ -86,8 +86,9 @@ def get_path_and_pattern(partial_path: str = '', base_path=str(Path('.'))) -> (s
 
 
 
-def run(partial_paths: list, base_path=str(Path('.'))) -> None:
-    '''Returns None, prints DEPS keys into pretty columns, using arg
+
+def get_targets(partial_paths: list, base_path=str(Path('.'))) -> list:
+    '''Returns a list of DEPS keys into pretty columns, using arg
 
     partial_path as a string filter for target completions.
     '''
@@ -113,7 +114,16 @@ def run(partial_paths: list, base_path=str(Path('.'))) -> None:
         for key in keys:
             targets_set.add(key)
 
-    data = list(targets_set)
+    return list(targets_set)
+
+
+def run(partial_paths: list, base_path=str(Path('.'))) -> None:
+    '''Returns None, prints DEPS keys into pretty columns, using arg
+
+    partial_path as a string filter for target completions.
+    '''
+
+    data = get_targets(partial_paths=partial_paths, base_path=base_path)
     data.sort()
     print_columns_manual(data=data, num_columns=4, auto_columns=True)
 

{opencos_eda-0.2.44 → opencos_eda-0.2.46}/opencos/tests/helpers.py

@@ -5,6 +5,7 @@
 import json
 import os
 import shutil
+from pathlib import Path
 
 from contextlib import redirect_stdout, redirect_stderr
 
@@ -26,7 +27,7 @@ def can_run_eda_command(*commands, config: dict) -> bool:
 
 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))
+    os.chdir(os.path.join(str(Path(startpath)), str(Path(relpath))))
     for outdir in ['eda.export', 'eda.work']:
         fullp = os.path.join(os.getcwd(), outdir)
         if fullp and ('eda.' in fullp) and os.path.isdir(fullp):