opencos-eda 0.3.5__tar.gz → 0.3.6__tar.gz

{opencos_eda-0.3.5/opencos_eda.egg-info → opencos_eda-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.3.5
+Version: 0.3.6
 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
@@ -16,11 +16,12 @@ Requires-Dist: schema>=0.7.7
 Requires-Dist: toml>=0.10.2
 Requires-Dist: yamllint>=1.35.1
 Requires-Dist: PySerial>=3.5
-Requires-Dist: cocotb>=2.0
 Requires-Dist: supports_color>=0.2.0
+Requires-Dist: cocotb>=2.0
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: coverage>=7.6.1
 Provides-Extra: dev
 Requires-Dist: pylint>=3.0.0; extra == "dev"
-Requires-Dist: pytest>=8.3.5; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == "docs"
 Requires-Dist: mkdocs-material; extra == "docs"

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/commands/sim.py

@@ -145,6 +145,7 @@ class CommandSim(CommandDesign):
             self.run_dep_commands()
             self.do_it()
             self.run_post_tool_dep_commands()
+            self.report_pass_fail()
         return unparsed
 
 
@@ -198,6 +199,9 @@ class CommandSim(CommandDesign):
 
             clist = list(obj).copy()
             tee_fpath = getattr(obj, 'tee_fpath', None)
+            work_dir = getattr(obj, 'work_dir', None)
+            if not work_dir:
+                work_dir = self.args['work-dir']
 
             util.debug(f'run_commands_check_logs: {clist=}, {tee_fpath=}')
 
@@ -207,24 +211,28 @@ class CommandSim(CommandDesign):
             if log_filename:
                 log_fname = log_filename
 
+
             _, stdout, _ = self.exec(
-                work_dir=self.args['work-dir'], command_list=clist, tee_fpath=tee_fpath
+                work_dir=work_dir, command_list=clist, tee_fpath=tee_fpath
             )
 
             if check_logs and log_fname:
                 # Note this call will check on stdout if not GUI, not opening the log_fname,
                 # but if this is GUI we normally lose stdout and have to open the log.
-                gui_mode = self.args.get('gui', False)
-                file_contents_str = '' if gui_mode else stdout
+                if self.args.get('gui', False):
+                    file_contents_str = ''
+                else:
+                    file_contents_str = stdout
+
                 self.check_logs_for_errors(
-                    filename=os.path.join(self.args['work-dir'], log_fname),
+                    filename=os.path.join(work_dir, log_fname),
                     file_contents_str=file_contents_str,
                     bad_strings=bad_strings, must_strings=must_strings,
                     use_bad_strings=use_bad_strings, use_must_strings=use_must_strings
                 )
             if log_fname:
                 self.artifacts_add(
-                    name=os.path.join(self.args['work-dir'], log_fname),
+                    name=os.path.join(work_dir, log_fname),
                     typ='text', description='Simulator stdout/stderr log file'
                 )
 
@@ -253,6 +261,7 @@ class CommandSim(CommandDesign):
         tool = self.args.get('tool', None)
         # Certain args are allow-listed here
         deps_file_args = []
+        print(f'SUPER DREW DEBUG: {self.get_command_line_args()=}')
         for a in self.get_command_line_args():
             if any(a.startswith(x) for x in [
                     '--compile-args',
@@ -265,7 +274,8 @@ class CommandSim(CommandDesign):
                     '--stop-',
                     '--lint-',
                     '--verilate',
-                    '--verilator']):
+                    '--verilator',
+                    '--cocotb-test-']):
                 deps_file_args.append(a)
 
         export_obj.run(

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/deps/deps_processor.py

@@ -10,7 +10,7 @@ import os
 from opencos import files
 from opencos import eda_config
 from opencos.util import debug, info, warning, error, read_tokens_from_dot_f, \
-    patch_args_for_dir
+    patch_args_for_dir, load_env_file
 from opencos.utils.str_helpers import dep_str2list
 from opencos.deps.deps_file import deps_target_get_deps_list
 from opencos.deps.deps_commands import deps_commands_handler
@@ -192,9 +192,15 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         # Since some args (util.py, eda_config.py, eda.py) can only be handled from command
         # line, it would be nice if -f or --input-file is handled from DEPS, so we'll special
         # case that now. Recursively resolve -f / --input-file.
+        # Do similary for --env-file (also only supported in util.py)
         parser = argparse.ArgumentParser(
             prog='deps_processor -f/--input-file', add_help=False, allow_abbrev=False
         )
+        parser.add_argument('--env-file', default=[], action='append',
+                            help=(
+                                "dotenv file(s) to pass ENV vars, (default: .env loaded first,"
+                                " subsequent files' vars override .env"
+                            ))
         parser.add_argument('-f', '--input-file', default=[], action='append',
                             help=(
                                 'Input .f file to be expanded as eda args, defines, incdirs,'
@@ -225,7 +231,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             # recurse until we've resolved nested .f files.
             return self.apply_args(args_list=tokens2)
 
-        tokens = tokens2 # if no --input-file values, keep parsing the remaining tokens2
+        if parsed.env_file:
+            for env_file in parsed.env_file:
+                load_env_file(env_file)
+
+        # if no --input-file/--env-file values, keep parsing the remaining tokens2:
+        tokens = tokens2
 
         # We have to special-case anything with --tool[=value] in tokens, otherwise
         # the user may think they were allowed to set --tool, but in our flow the Command handler

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/eda.py

@@ -20,6 +20,7 @@ from pathlib import Path
 
 import opencos
 from opencos import util, eda_config, eda_base
+from opencos.util import safe_emoji
 from opencos.eda_base import Tool, which_tool, get_eda_exec
 from opencos.utils import vsim_helper, vscode_helper
 from opencos.utils.subprocess_helpers import subprocess_run_background
@@ -95,15 +96,15 @@ def usage(tokens: list, config: dict, command: str = "", tool: str = "") -> int:
 
     if command == "":
         print(
-"""
-Usage:
+f"""
+{safe_emoji("🔦 ")}Usage:
     eda [<options>] <command> [options] <files|targets, ...>
 """
         )
         print(get_all_commands_help_str(config=config))
         print(
-"""
-And <files|targets, ...> is one or more source file or DEPS markup file target,
+f"""
+{safe_emoji("❕ ")}where <files|targets, ...> is one or more source file or DEPS markup file target,
     such as .v, .sv, .vhd[l], .cpp files, or a target key in a DEPS.[yml|yaml|toml|json].
     Note that you can prefix source files with `sv@`, `v@`, `vhdl@` or `cpp@` to
     force use that file as systemverilog, verilog, vhdl, or C++, respectively.
@@ -495,7 +496,7 @@ def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> i
 def signal_handler(sig, frame) -> None: # pylint: disable=unused-argument
     '''Handles Ctrl-C, called by main_cli() if running from command line'''
     util.fancy_stop()
-    util.info('Received Ctrl+C...', start='\nINFO: [EDA] ')
+    util.error(f'{safe_emoji("❌ ")}Received Ctrl+C...', start='\nINFO: [EDA] ')
     subprocess_helpers.cleanup_all()
     util.exit(-1)
 

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/eda_base.py

@@ -24,7 +24,7 @@ from pathlib import Path
 from opencos import seed, util, files
 from opencos import eda_config
 
-from opencos.util import Colors
+from opencos.util import Colors, safe_emoji
 from opencos.utils.str_helpers import sprint_time, strip_outer_quotes, string_or_space, \
     indent_wrap_long_text, pretty_list_columns_manual
 from opencos.utils.subprocess_helpers import subprocess_run_background
@@ -44,7 +44,9 @@ def print_base_help() -> None:
 
 def get_argparser() -> argparse.ArgumentParser:
     '''Returns the ArgumentParser for general eda CLI'''
-    parser = argparse.ArgumentParser(prog='eda options', add_help=False, allow_abbrev=False)
+    parser = argparse.ArgumentParser(
+        prog=f'{safe_emoji("🔎 ")}eda options', add_help=False, allow_abbrev=False
+    )
     parser.add_argument('-q', '--quit', action='store_true',
                         help=(
                             'For interactive mode (eda called with no options, command, or'
@@ -313,6 +315,18 @@ class Command: # pylint: disable=too-many-public-methods
             util.error(f"command '{self.command_name}' has previous errors")
         return self.status > 0
 
+    def report_pass_fail(self) -> None:
+        '''Reports an INFO line with pass/fail information'''
+        job_name = ' - '.join(
+            x for x in (self.command_name, self.args.get('tool', ''),
+                        self.args.get('top', '')) if x
+        )
+        if self.status_any_error():
+            util.info(f'{safe_emoji("❌ ")}{job_name}: Errors observed.', color=Colors.red)
+        else:
+            util.info(f'{safe_emoji("✅ ")}{job_name}: No errors observed.')
+
+
     def which_tool(self, command:str) -> str:
         '''Returns a str for the tool name used for the requested command'''
         return which_tool(command, config=self.config)
@@ -462,7 +476,8 @@ class Command: # pylint: disable=too-many-public-methods
         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=})")
+            util.info(f"{safe_emoji('⏩ ')}exec: {' '.join(command_list)}",
+                      f"(in {work_dir}, {tee_fpath=})")
 
         stdout, stderr, return_code = subprocess_run_background(
             work_dir=work_dir,
@@ -484,7 +499,8 @@ class Command: # pylint: disable=too-many-public-methods
                 self.error(f"exec: returned with error (return code: {return_code})",
                            error_code=self.status)
             else:
-                util.debug(f"exec: returned with error (return code: {return_code})")
+                util.debug(f"{safe_emoji('❌ ')}exec: returned with error (return code:",
+                           f"{return_code})")
         else:
             util.debug(f"exec: returned without error (return code: {return_code})")
         return stderr, stdout, return_code
@@ -564,7 +580,9 @@ class Command: # pylint: disable=too-many-public-methods
         # parsed.args-with-dashes is not legal python. Some of self.args.keys() still have - or _,
         # so this will handle both.
         # Also, preference is for self.args.keys(), to be str with - dashes
-        parser = argparse.ArgumentParser(prog='eda', add_help=False, allow_abbrev=False)
+        parser = argparse.ArgumentParser(
+            prog=f'{safe_emoji("🔎 ")}eda', add_help=False, allow_abbrev=False
+        )
         bool_action_kwargs = util.get_argparse_bool_action_kwargs()
 
         if not parser_arg_list:
@@ -797,7 +815,7 @@ class Command: # pylint: disable=too-many-public-methods
         util.info('Help:')
         # using bare 'print' here, since help was requested, avoids --color and --quiet
         print()
-        print('Usage:')
+        print(f'{safe_emoji("🔦 ")}Usage:')
         if no_targets:
             print(f'    eda [options] {self.command_name} [options]')
         else:
@@ -811,10 +829,10 @@ class Command: # pylint: disable=too-many-public-methods
             return
 
         if self.command_name:
-            lines.append(f"Generic help for command='{self.command_name}'"
+            lines.append(f"{safe_emoji('🔧 ')}Generic help for command='{self.command_name}'"
                          f" (using '{self.__class__.__name__}')")
         else:
-            lines.append("Generic help (from class Command):")
+            lines.append("{safe_emoji('🔧 ')}Generic help (from class Command):")
 
         # Attempt to run argparser on args, but don't error if it fails.
         unparsed = []
@@ -980,6 +998,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         self.files_vhd = []
         self.files_cpp = []
         self.files_sdc = []
+        self.files_py = []
+        self.files_makefile = []
         self.files_non_source = []
         self.files_caller_info = {}
         self.dep_shell_commands = [] # each list entry is a {}
@@ -1139,7 +1159,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 self.files[new_key] = True
 
         my_file_lists_list = [self.files_v, self.files_sv, self.files_vhd, self.files_cpp,
-                              self.files_sdc]
+                              self.files_sdc, self.files_py, self.files_makefile]
         for my_file_list in my_file_lists_list:
             for i,value in enumerate(my_file_list):
                 if value and isinstance(value, str) and \
@@ -1157,9 +1177,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         need to be copied or linked to the work-dir. For example, if some SV assumes it
         can $readmemh('file_that_is_here.txt') but we're running out of work-dir. Linking
         is the easy work-around vs trying to run-in-place of all SV files.
+
+        Note that we also include .py and Makefile(s) in this.
         '''
 
-        for fname in self.files_non_source:
+        for fname in self.files_non_source + self.files_py + self.files_makefile:
             _, leaf_fname = os.path.split(fname)
             destfile = os.path.join(self.args['work-dir'], leaf_fname)
             relfname = os.path.relpath(fname)
@@ -1518,7 +1540,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # if we've found any target since being called, it means we found the one we were called for
         return found_target
 
-    def add_file( # pylint: disable=too-many-locals,too-many-branches
+    def add_file( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
             self, filename: str, use_abspath: bool = True, add_to_non_sources: bool = False,
             caller_info: str = '', forced_extension: str = ''
     ) -> str:
@@ -1543,6 +1565,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         cpp_file_ext_list = known_file_ext_dict.get('cpp', [])
         sdc_file_ext_list = known_file_ext_dict.get('synth_constraints', [])
         dotf_file_ext_list = known_file_ext_dict.get('dotf', [])
+        py_file_ext_list = known_file_ext_dict.get('python', [])
+        makefile_ext_list = known_file_ext_dict.get('makefile', [])
 
         if forced_extension:
             # If forced_extension='systemverilog', then use the first known extension for
@@ -1582,6 +1606,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                                caller_info=caller_info)
             dp.apply_args(args_list=[f'-f={file_abspath}'])
             del dp
+        elif file_ext in py_file_ext_list:
+            self.files_py.append(file_abspath)
+            util.debug(f"Added Python file {filename} as {file_abspath}")
+        elif file_ext in makefile_ext_list or os.path.split(filename)[1] == 'Makefile':
+            self.files_makefile.append(file_abspath)
+            util.debug(f"Added Makefile {filename} as {file_abspath}")
         else:
             # unknown file extension. In these cases we link the file to the working directory
             # so it is available (for example, a .mem file that is expected to exist with relative
@@ -2114,21 +2144,22 @@ class CommandParallel(Command):
                     work_queue.put((jobs_launched, command_list, job['name'], cwd))
                     suffix = "<START>"
                     if fancy_mode:
-                        util.fancy_print(job_text+suffix, worker)
+                        util.fancy_print(job_text + suffix, worker)
                     elif failed_jobs:
                         # if we aren't in fancy mode, we will print a START line, periodic RUNNING
                         # lines, and PASS/FAIL line per-job
-                        util.print_orange(job_text + Colors.yellow + suffix)
+                        util.print_yellow(job_text, end='')
+                        util.print_foreground_color(suffix)
                     else:
-                        util.print_yellow(job_text + Colors.yellow + suffix)
+                        util.print_foreground_color(job_text + suffix)
                 else:
                     # single-threaded job launch, we are going to print out job info as we start
                     # each job... no newline. since non-verbose silences the job and prints only
                     # <PASS>/<FAIL> after the trailing "..." we leave here
                     if failed_jobs:
-                        util.print_orange(job_text, end="")
-                    else:
                         util.print_yellow(job_text, end="")
+                    else:
+                        util.print_foreground_color(job_text, end="")
                     job_done_number = jobs_launched
                     job_done_name = job['name']
                     job_start_time = time.time()
@@ -2182,9 +2213,10 @@ class CommandParallel(Command):
                         if fancy_mode:
                             util.fancy_print(f"{job_text}{suffix}", t['worker'])
                         elif failed_jobs:
-                            util.print_orange(job_text + Colors.yellow + suffix)
+                            util.print_yellow(job_text, end='')
+                            util.print_foreground_color(suffix)
                         else:
-                            util.print_yellow(job_text + Colors.yellow + suffix)
+                            util.print_foreground_color(job_text + suffix)
 
             # shared job completion code
             # single or multi-threaded, we can arrive here to harvest <= 1 jobs, and need
@@ -2192,36 +2224,52 @@ class CommandParallel(Command):
             # printed, ready for pass/fail
             if job_done:
                 jobs_complete += 1
+                this_job_failed = False
                 if job_done_return_code is None or job_done_return_code:
-                    # embed the color code, to change color of pass/fail during the
-                    # util.print_orange/yellow below
                     if job_done_return_code == 124:
                         # bash uses 124 for bash timeout errors, if that was preprended to the
                         # command list.
-                        suffix = f"{Colors.red}<TOUT: {sprint_time(job_done_run_time)}>"
+                        suffix = (
+                            f"<TOUT{safe_emoji(' ❌')}:"
+                            f" {sprint_time(job_done_run_time)}>"
+                        )
+                        this_job_failed = True
                     else:
-                        suffix = f"{Colors.red}<FAIL: {sprint_time(job_done_run_time)}>"
+                        suffix = (
+                            f"<FAIL{safe_emoji(' ❌')}:"
+                            f" {sprint_time(job_done_run_time)}>"
+                        )
+                        this_job_failed = True
                     failed_jobs.append(job_done_name)
                 else:
-                    suffix = f"{Colors.green}<PASS: {sprint_time(job_done_run_time)}>"
+                    suffix = (
+                        f"<PASS{safe_emoji(' ✅')}:"
+                        f" {sprint_time(job_done_run_time)}>"
+                    )
                     passed_jobs.append(job_done_name)
                 # we want to print in one shot, because in fancy modes that's all that we're allowed
                 job_done_text = "" if job_done_quiet else sprint_job_line(job_done_number,
                                                                           job_done_name)
-                if failed_jobs:
-                    util.print_orange(f"{job_done_text}{suffix}")
-                else:
+                if this_job_failed:
+                    util.print_red(f"{job_done_text}{suffix}")
+                elif failed_jobs:
                     util.print_yellow(f"{job_done_text}{suffix}")
+                else:
+                    util.print_green(f"{job_done_text}{suffix}")
                 self.jobs_status[job_done_number-1] = job_done_return_code
 
             if not anything_done:
                 time.sleep(0.25) # if nothing happens for an iteration, chill out a bit
 
         if total_jobs:
-            emoji = "< :) >" if (len(passed_jobs) == total_jobs) else "< :( >"
-            util.info(sprint_job_line(final=True, job_name="jobs passed") + emoji, start="")
+            if len(passed_jobs) == total_jobs:
+                emojitxt = safe_emoji('😀', ':)')
+            else:
+                emojitxt = safe_emoji('😦', ':(')
+            util.info(sprint_job_line(final=True, job_name="jobs passed") + f"< {emojitxt} >",
+                      start="")
         else:
-            util.info("Parallel: <No jobs found>")
+            util.info(f"Parallel: <{safe_emoji('❓ ')}No jobs found>")
         # Make sure all jobs have a set status:
         for i, rc in enumerate(self.jobs_status):
             if rc is None or not isinstance(rc, int):

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/eda_config.py

@@ -15,6 +15,7 @@ import shutil
 import mergedeep
 
 from opencos import util
+from opencos.util import safe_emoji
 from opencos.utils.markup_helpers import yaml_safe_load, yaml_safe_writer
 
 class Defaults:
@@ -231,7 +232,7 @@ def get_config_merged_with_defaults(config:dict) -> dict:
 def get_argparser() -> argparse.ArgumentParser:
     '''Returns an ArgumentParser, handles --config-yml=<filename> arg'''
     parser = argparse.ArgumentParser(
-        prog='opencos eda config options', add_help=False, allow_abbrev=False
+        prog=f'{safe_emoji("🔎 ")}opencos eda config options', add_help=False, allow_abbrev=False
     )
     parser.add_argument('--config-yml', type=str, default=Defaults.config_yml,
                         help=('YAML filename to use for configuration (default'

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/eda_config_defaults.yml

@@ -94,6 +94,11 @@ file_extensions:
   dotf:
     - .f
     - .vc
+  python:
+    - .py
+  makefile:
+    - .mk
+
 
   inferred_top:
     # file extensions that we can infer "top" module from, if --top omitted.
@@ -332,7 +337,6 @@ tools:
       - "COCOTB_TEST_FAILED"
     log-must-strings:
       - "passed"
-      - "Cocotb test completed successfully!"
 
 
   quartus:

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/export_helper.py

@@ -42,12 +42,18 @@ def json_paths_to_jsonl(
     with open(output_json_path, 'w', encoding='utf-8') as outf:
 
         # jsonl is every line of the file is a json.
+        # We would expect the JSON to have "tests": [ ... ] with >= 1 test.
         for json_file_path in json_file_paths:
             with open(json_file_path, encoding='utf-8') as f:
                 data = json.load(f)
                 if len(assert_json_types) > 0 and type(data) not in assert_json_types:
                     error(f'{json_file_path=} JSON data is not a Table (py dict) {type(data)=}')
-                json.dump(data, outf)
+                if 'tests' in data and isinstance(data['tests'], list):
+                    for test in data['tests']:
+                        json.dump(test, outf)
+                else:
+                    json.dump(data, outf)
+
                 outf.write('\n')
         info(f'Wrote {len(json_file_paths)} tests to {output_json_path=}')
 
@@ -78,7 +84,12 @@ def json_paths_to_single_json(
                 data = json.load(f)
                 if len(assert_json_types) > 0 and type(data) not in assert_json_types:
                     error(f'{json_file_path=} JSON data is not a Table (py dict) {type(data)=}')
-                out_json_data['tests'].append(data)
+                if 'tests' in data and isinstance(data['tests'], list):
+                    for test in data['tests']:
+                        out_json_data['tests'].append(test)
+                else:
+                    out_json_data['tests'].append(data)
+
         json.dump(out_json_data, outf)
         outf.write('\n')
         info(f'Wrote {len(json_file_paths)} tests {output_json_path=}')
@@ -471,7 +482,52 @@ class ExportHelper:
         yaml_safe_writer(data=data, filepath=dst)
 
 
-    def create_export_json_in_out_dir( # pylint: disable=unused-argument
+    def create_combined_env_file_in_out_dir(self) -> list:
+        ''' Returns list of all .env lines to be put in output directory
+
+        Creates single exported .env file if any --env-file(s)
+        were loaded by CLI or DEPS targets. --input-file/-f was handled as args
+        already, but --env-files need to be special cased. We do not add this
+        combined ".env" file to the all_files list, just build it on the fly if needed.
+        '''
+        env_lines = []
+        for filepath in util.env_files_loaded:
+            with open(filepath, encoding='utf-8') as f:
+                env_lines.extend(f.readlines() + ['\n'])
+
+        if env_lines:
+            dst = os.path.join(self.out_dir, '.env')
+
+            # Write this to the export directory too:
+            with open(dst, 'w', encoding='utf-8') as f:
+                for lineno, line in enumerate(env_lines):
+
+                    # modify VERILOG_SOURCES line if present, although it is known via DEPS.yml,
+                    # we can set it according to files_v and files_sv:
+                    if line.strip().startswith('VERILOG_SOURCES'):
+                        base_verilog_filenames = [
+                            os.path.split(x)[1] for x in \
+                            self.cmd_design_obj.files_v + self.cmd_design_obj.files_sv
+                        ]
+                        env_lines[lineno] = (
+                            f'VERILOG_SOURCES = {" ".join(base_verilog_filenames)}'
+                        )
+                        continue
+
+                    # remove PYTHONPATH from .env
+                    if line.strip().startswith('PYTHONPATH'):
+                        env_lines[lineno] = ''
+                        continue
+
+                    f.write(line)
+
+
+            info(f'export_helper: Wrote {dst}')
+
+        return env_lines
+
+
+    def create_export_json_in_out_dir( # pylint: disable=unused-argument,too-many-locals,too-many-branches
             self, eda_config:dict={}, **kwargs
     ) -> None:
         '''Optionally creates an exported JSON file in the output directory'''
@@ -482,40 +538,43 @@ class ExportHelper:
         # assumes we've run self.create_deps_yml_in_out_dir():
         assert self.target
         assert self.out_deps_file
+        full_eda_cmd_list = ['eda', self.eda_command]
+        if self.args.get('waves', False):
+            full_eda_cmd_list.append('--waves')
+        if self.args.get('tool', ''):
+            full_eda_cmd_list.append(f'--tool={self.args["tool"]}')
+        full_eda_cmd_list.append(self.target)
 
         data = {
-            'name': self.target,
-            'eda': {
-                'enable': True,
-                'multi': False, # Not yet implemented.
-                'command': self.eda_command,
-                'targets': [self.target],
-                'args': [],
-                'waves': self.args.get('waves', False),
-                # tool - eda.CommandSimVerilator has this set in self.args:
-                'tool': self.args.get('tool', None),
-            },
-            'files': [],
+            'correlationId': self.target,
+            'jobType': 'edaCmd',
+            'cmd': ' '.join(full_eda_cmd_list),
+            'timeout': 600,
+            'filesList': [], # filename (str), content (str)
         }
 
-        # allow caller to override eda - tool, or eda - args, etc.
-        for k,v in eda_config.items():
-            if k in data['eda'] and v is not None:
-                data['eda'][k] = v
-
         # Note that args may already be set via:
         #   create_deps_yml_in_out_dir(deps_file_args=some_list)
         # For example, eda.CommandSim.do_export() will set certain allow-listed
         # args if present with non-default values.
 
-
         all_files = [self.out_deps_file] + self.included_files \
             + self.cmd_design_obj.files_sv + self.cmd_design_obj.files_v \
             + self.cmd_design_obj.files_vhd + self.cmd_design_obj.files_cpp \
+            + self.cmd_design_obj.files_sdc + self.cmd_design_obj.files_py \
+            + self.cmd_design_obj.files_makefile + self.cmd_design_obj.files_non_source
+
+        all_files = list(dict.fromkeys(all_files)) # uniqify list.
+
+        # The last file we handle is a single exported .env file if any --env-file(s)
+        env_lines = self.create_combined_env_file_in_out_dir()
+        if env_lines:
+            # write the updated env_lines to the export.json file.
+            data['filesList'].append({
+                'filename': '.env',
+                'content': ''.join(env_lines), # already has \n per line
+            })
 
-        for x in self.cmd_design_obj.files_non_source:
-            if x not in all_files:
-                all_files.append(x)
 
         for somefile in all_files:
 
@@ -532,18 +591,17 @@ class ExportHelper:
 
             assert os.path.exists(somefile)
             with open(somefile, encoding='utf-8') as f:
-                filestr = ''.join(f.readlines())
-                data['files'].append({
-                    'name': os.path.split(somefile)[1],
-                    'content': filestr,
+                data['filesList'].append({
+                    'filename': os.path.split(somefile)[1],
+                    'content': ''.join(f.readlines()),
                 })
 
-
+        test_runner_data = {'tests': [data]} # single test for test runner.
         dst = os.path.join(self.out_dir, 'export.json')
         with open(dst, 'w', encoding='utf-8') as f:
-            json.dump(data, f)
+            json.dump(test_runner_data, f)
             f.write('\n')
-        info(f'export_helper: Wrote {dst=}')
+        info(f'export_helper: Wrote {dst}')
 
         # If this was from an `export` command, and the self.out_dir != self.args['work-dir'], then
         # copy the export.json to the work-dir:

{opencos_eda-0.3.5 → opencos_eda-0.3.6}/opencos/files.py

@@ -24,7 +24,9 @@ FORCE_PREFIX_DICT = {
     'vhdl@': 'vhdl',
     'cpp@': 'cpp',
     'sdc@': 'synth_constraints',
-    'f@': 'dotf'
+    'f@': 'dotf',
+    'py@' : 'python',
+    'makefile@': 'makefile'
 }
 
 ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))