opencos-eda 0.2.44__py3-none-any.whl → 0.2.45__py3-none-any.whl

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/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/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/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.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_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()
@@ -740,9 +742,9 @@ 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
-            #  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(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath, shell=True)
             else:
                 self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
                           shell=self.config.get('deps_subprocess_shell', False))
@@ -1160,7 +1162,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.

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
 
 
@@ -337,6 +339,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 +365,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_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/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):

opencos/tests/test_deps_schema.py

@@ -16,7 +16,9 @@ def test_all_deps():
     for root, _, files in os.walk(os.getcwd()):
         for fname in files:
             if fname.startswith('DEPS') and \
-               any(fname.endswith(x) for x in ['.yml', '.json', '.toml', 'DEPS']):
+               any(fname.endswith(x) for x in [
+                   '.yml', '.yaml', '.json', '.toml', 'DEPS'
+               ]):
 
                 all_deps_files.append(os.path.join(root, fname))
 

opencos/tests/test_eda.py

@@ -692,14 +692,22 @@ 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():
+@pytest.mark.parametrize("command", ['sim', 'shell'])
+def test_deps_command_order(command):
     '''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
     all commands deps order, and then execute them in that order.'''
 
     chdir_remove_work_dir('deps_files/command_order')
-    cmd_list = 'sim --stop-before-compile target_test'.split()
+    if command == 'sim' and not can_run_eda_sim():
+        pytest.skip(f'sim skipped, {can_run_eda_sim()=}')
+        return # skip/pass
+
+    if command == 'shell':
+        cmd_list = 'shell target_test'.split()
+    else:
+        cmd_list = 'sim --stop-before-compile target_test'.split()
+
     with open('eda.log', 'w', encoding='utf-8') as f:
         with redirect_stdout(f):
             with redirect_stderr(f):
@@ -730,14 +738,16 @@ 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', f'target_test.{command}'
+    )
     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'
+        assert text in ['hi', '"hi"', '\\"hi\\"']
     # Added check, one of the targets uses a custom 'tee' file name, instead of the default log.
     with open(os.path.join(work_dir, 'custom_tee_echo_bye.log'), encoding='utf-8') as f:
         text = ''.join(f.readlines()).strip()
-        assert text == 'bye'
+        assert text in ['bye', '"bye"', '\\"bye\\"']
 
 
 @pytest.mark.skipif('verilator' not in tools_loaded, reason="requires verilator")
@@ -896,9 +906,9 @@ class TestDepsTags(Helpers):
         # b/c that should only apply in 'verilator' for this target.)
         exec_lines = self.get_log_lines_with('exec: ', logfile=logfile)
         assert len(exec_lines) == 3
-        assert 'xvlog ' in exec_lines[0]
-        assert 'xelab ' in exec_lines[1]
-        assert 'xsim ' in exec_lines[2]
+        assert 'xvlog' in exec_lines[0]
+        assert 'xelab' in exec_lines[1]
+        assert 'xsim' in exec_lines[2]
         assert not self.is_in_log('--lint-only', logfile=logfile)
 
 

opencos/tools/invio_yosys.py

@@ -51,7 +51,7 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
             'invio-blackbox': 'List of modules that invio will blackbox prior to yosys',
         })
 
-    def write_and_run_yosys_f_files(self, **kwargs) -> None:
+    def write_and_run_yosys_f_files(self) -> None:
 
         # Use helper module for Invio/Verific to save out Verilog-2001 from our
         # Verilog + SystemVerilog + VHDL file lists.
@@ -104,7 +104,7 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
         )
 
         # Optinally create and run a sta.f:
-        sta_command_list = self.create_sta_f() # [] or util.ShellCommandList
+        sta_command_lists = self.create_sta_f() # [] or [util.ShellCommandList]
 
         # We create a run_yosys.sh wrapping these scripts, but we do not run this one.
         util.write_shell_command_file(
@@ -122,8 +122,7 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
                 # Gives us bash commands with tee and pipstatus:
                 invio_command_list,
                 synth_command_list,
-                sta_command_list,
-            ],
+            ] + sta_command_lists,
         )
 
         # Do not run this if args['stop-before-compile'] is True
@@ -135,9 +134,10 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
         self.exec( work_dir=work_dir, command_list=synth_command_list,
                    tee_fpath=synth_command_list.tee_fpath )
 
-        if self.args['sta']:
-            self.exec(work_dir=self.full_work_dir, command_list=sta_command_list,
-                      tee_fpath=sta_command_list.tee_fpath)
+        for x in sta_command_lists:
+            if self.args['sta'] and x:
+                self.exec(work_dir=self.full_work_dir, command_list=x,
+                          tee_fpath=x.tee_fpath)
 
         if self.status == 0:
             util.info(f'yosys: wrote verilog to {self.yosys_v_path}')