opencos-eda 0.2.48__py3-none-any.whl → 0.2.49__py3-none-any.whl

opencos/export_helper.py

@@ -1,38 +1,49 @@
+''' opencos.export_helper: package used by command sim and synth,
+
+to handle common tasks with "exporting" a DEPS target. An exported target copies all
+source files (deps, reqs) and attempts to resolve included files so they are all relative
+to +incdir+.
+'''
+
 import os
 import shutil
 import json
 
 from opencos import util
 from opencos.util import debug, info, warning, error
+from opencos.utils.markup_helpers import yaml_safe_writer
 
+# pylint: disable=dangerous-default-value
 
-_include_iteration_max_depth = 128 # Depth to look for nested included files.
-_remove_DEPS_yml_defines = [
+
+SV_INCLUDE_ITERATION_MAX_DEPTH = 128 # Depth to look for nested included files.
+REMOVE_DEPS_YML_DEFINES = [
     'OC_SEED',
     'OC_ROOT',
 ]
 
 
-def json_paths_to_jsonl(json_file_paths:list, output_json_path:str,
-                        assert_json_types=[dict]) -> None:
+def json_paths_to_jsonl(
+        json_file_paths:list, output_json_path:str, assert_json_types=[dict]
+) -> None:
     '''Given a list of .json filepath strs, save a single .jsonl (newline separated json(s)).
 
     errors if one of json_file_paths content's type is not in assert_json_types
     (assert_json_types can be empty list to avoid check).
     '''
 
-    if len(json_file_paths) == 0:
+    if not json_file_paths:
         error(f'{json_file_paths=} cannot be empty list')
 
 
     output_json_dir = os.path.split(output_json_path)[0]
     util.safe_mkdir(output_json_dir)
 
-    with open(output_json_path, 'w') as outf:
+    with open(output_json_path, 'w', encoding='utf-8') as outf:
 
         # jsonl is every line of the file is a json.
         for json_file_path in json_file_paths:
-            with open(json_file_path) as f:
+            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)=}')
@@ -41,8 +52,9 @@ def json_paths_to_jsonl(json_file_paths:list, output_json_path:str,
         info(f'Wrote {len(json_file_paths)} tests to {output_json_path=}')
 
 
-def json_paths_to_single_json(json_file_paths:list, output_json_path:str,
-                              assert_json_types=[dict]) -> None:
+def json_paths_to_single_json(
+        json_file_paths:list, output_json_path:str, assert_json_types=[dict]
+) -> None:
     '''Given a list of .json filepath strs, save a single .json with key 'tests' and a list.
 
     errors if one of json_file_paths content's type is not in assert_json_types
@@ -56,13 +68,13 @@ def json_paths_to_single_json(json_file_paths:list, output_json_path:str,
     output_json_dir = os.path.split(output_json_path)[0]
     util.safe_mkdir(output_json_dir)
 
-    with open(output_json_path, 'w') as outf:
+    with open(output_json_path, 'w', encoding='utf-8') as outf:
 
         out_json_data = {
-            'tests': list(),
+            'tests': [],
         }
         for json_file_path in json_file_paths:
-            with open(json_file_path) as f:
+            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)=}')
@@ -72,35 +84,22 @@ def json_paths_to_single_json(json_file_paths:list, output_json_path:str,
         info(f'Wrote {len(json_file_paths)} tests {output_json_path=}')
 
 
-def find_sv_included_files_within_file(filename:str,
-                                       known_incdir_paths:list,
-                                       warnings:bool=True,
-                                       modify_files_and_save_to_path=None,
-                                       unmodified_files_copy_to_path=None) -> list:
-    '''Given a filename (full path) and a list of known incdir paths, returns
-    a list of included files (full path).
+def traverse_sv_file_for_includes(filename: str) -> (dict, set):
+    '''Lazily parses a SV <filename> looking for `includes
 
-    (Optional) modify_files_and_save_to_path (str: directory/path) if you wish
-    to strip all path information on the `include "(path)" for example:
-      `include "foo.svh" -- no modifications
-      `include "../bar.svh" -- is modified to become `include "bar.svh"
-    (Optional) unmodified_files_copy_to_path (str: directory/path) if you wish
-    to copy unmodified files to this path.
+    Returns tuple:
+       - dict of modified_lines: {linenum (int): line (str, modified line value), ...}
+       - set of found included files
     '''
 
-    found_included_files = set()
-
     assert any(filename.endswith(x) for x in ['.v', '.sv', '.vh', '.svh']), \
         f'{filename=} does not have a supported extension, refusing to parse it'
     assert os.path.exists(filename), f'{filename=} does not exist'
 
-    modified_lines = dict() # {linenum (int): line (str, modified line value), ...}
-
-    filename_no_path = os.path.split(filename)[1]
-
-    debug(f'export_helper: {filename=} {modify_files_and_save_to_path=} {unmodified_files_copy_to_path=}')
+    found_included_files = set()
+    modified_lines = {}
 
-    with open(filename) as f:
+    with open(filename, encoding='utf-8') as f:
 
         for linenum, line in enumerate(f.readlines()):
             line_modified = False
@@ -112,7 +111,7 @@ def find_sv_included_files_within_file(filename:str,
                 parts = line.split("//")
                 words = parts[0].split() # only use what's on the left of the comments
                 prev_word_is_tick_include = False
-                for iter,word in enumerate(words):
+                for i,word in enumerate(words):
                     word = word.rstrip('\n')
                     if word == '`include':
                         # don't print this word, wait until next word
@@ -125,11 +124,10 @@ def find_sv_included_files_within_file(filename:str,
 
                         # strip the path information and keep track that
                         # we would like to modify this line of filename
-                        if modify_files_and_save_to_path:
-                            include_fname_no_path = os.path.split(include_fname)[1]
-                            if include_fname != include_fname_no_path:
-                                words[iter] = '"' + include_fname_no_path + '"'
-                                line_modified = True
+                        _, include_fname_no_path = os.path.split(include_fname)
+                        if include_fname != include_fname_no_path:
+                            words[i] = '"' + include_fname_no_path + '"'
+                            line_modified = True
 
                         if include_fname not in found_included_files:
                             # this has path information, perhaps relative, perhaps absolute, or
@@ -139,33 +137,85 @@ def find_sv_included_files_within_file(filename:str,
                 if line_modified:
                     modified_lines[linenum] = ' '.join(words)
 
-    debug(f'export_helper: {filename=} {modified_lines=}')
+    return modified_lines, found_included_files
+
+
+def write_modified_lines(
+        src_filename: str,
+        modified_lines: dict,
+        modify_files_and_save_to_path: str = '',
+        unmodified_files_copy_to_path: str = ''
+) -> None:
+    '''Given a dict of modified lines, walk the src_filename contents and write modifications
+
+    to the dst_filename. The modified_lines dict is:
+       {linenum (int): line (str, modified line value), ...}
+    '''
+
+    debug(f'export_helper: {src_filename=} {modified_lines=}')
+
+    _, src_filename_no_path = os.path.split(src_filename)
+
     # Optionally write out modified files (flatten the path information
     # on `include "../bar.svh" )
-    if len(modified_lines) > 0 and modify_files_and_save_to_path:
-        dst = os.path.join(modify_files_and_save_to_path, filename_no_path)
+    if modified_lines and modify_files_and_save_to_path:
+        dst = os.path.join(modify_files_and_save_to_path, src_filename_no_path)
         if not os.path.exists(dst):
-            with open(filename) as f, open(dst, 'w') as outf:
+            with open(src_filename, encoding='utf-8') as f, \
+                 open(dst, 'w', encoding='utf-8') as outf:
                 for linenum, line in enumerate(f.readlines()):
                     if linenum in modified_lines:
                         new_line = modified_lines[linenum]
                         outf.write(new_line + '\n')
-                        debug(f'export_helper: Modified {filename=} as {dst=}: {linenum=} {new_line=}')
+                        debug(f'export_helper: Modified {src_filename=} as {dst=}:',
+                              f'{linenum=} {new_line=}')
                     else:
                         outf.write(line)
 
     # Copy unmodified files to some path.
-    if len(modified_lines) == 0 and unmodified_files_copy_to_path:
+    if not modified_lines and unmodified_files_copy_to_path:
         if os.path.isdir(unmodified_files_copy_to_path):
-            dst = os.path.join(unmodified_files_copy_to_path, filename_no_path)
+            dst = os.path.join(unmodified_files_copy_to_path, src_filename_no_path)
             if not os.path.exists(dst):
-                debug(f'export_helper: Copied unmodified {filename=} to {dst=}')
-                shutil.copy(src=filename, dst=dst)
+                debug(f'export_helper: Copied unmodified {src_filename=} to {dst=}')
+                shutil.copy(src=src_filename, dst=dst)
 
 
+def find_sv_included_files_within_file(
+        filename: str,
+        known_incdir_paths: list,
+        warnings: bool = True,
+        modify_files_and_save_to_path: str = '',
+        unmodified_files_copy_to_path: str = ''
+) -> list:
+    '''Given a filename (full path) and a list of known incdir paths, returns
+    a list of included files (full path).
+
+    (Optional) modify_files_and_save_to_path (str: directory/path) if you wish
+    to strip all path information on the `include "(path)" for example:
+      `include "foo.svh" -- no modifications
+      `include "../bar.svh" -- is modified to become `include "bar.svh"
+    (Optional) unmodified_files_copy_to_path (str: directory/path) if you wish
+    to copy unmodified files to this path.
+    '''
+
+    modified_lines, found_included_files = traverse_sv_file_for_includes(filename)
+
+    debug(f'export_helper: {filename=} {modify_files_and_save_to_path=}',
+          f'{unmodified_files_copy_to_path=}')
+
+    if modify_files_and_save_to_path or unmodified_files_copy_to_path:
+        # Save outputs to these paths:
+        write_modified_lines(
+            src_filename=filename,
+            modified_lines=modified_lines,
+            modify_files_and_save_to_path=modify_files_and_save_to_path,
+            unmodified_files_copy_to_path=unmodified_files_copy_to_path
+        )
+
     # Back to the list found_included_files that we observed within our filename, we
     # still need to return all the included files.
-    ret = list()
+    ret = []
     for fname in found_included_files:
         # Does this file exist, using our known_incdir_paths?
         found = False
@@ -175,7 +225,8 @@ def find_sv_included_files_within_file(filename:str,
                 if try_file_path not in ret:
                     ret.append(try_file_path)
                     found = True
-                    debug(f'export_helper: Include observed in {filename=} will use {try_file_path=} for export')
+                    debug(f'export_helper: Include observed in {filename=} will use',
+                          f'{try_file_path=} for export')
                     break # we can only match one possible file out of N possible incdir paths.
 
 
@@ -183,18 +234,20 @@ def find_sv_included_files_within_file(filename:str,
             # file doesn't exist in any included directory, we only warn here b/c
             # it will eventually fail compile.
             include_fname = fname
-            warning( f'export_helper: {include_fname=} does not exist in any of {known_incdir_paths=},' \
-                     + f'was included within source files: {filename=}'
-                    )
+            warning(f'export_helper: {include_fname=} does not exist in any of'
+                    f'{known_incdir_paths=}, was included within source files: {filename=}')
 
     return ret
 
 
-
-def get_list_sv_included_files(all_src_files:list, known_incdir_paths:list, target:str='',
-                               warnings:bool=True,
-                               modify_files_and_save_to_path=None,
-                               unmodified_files_copy_to_path=None) -> list:
+def get_list_sv_included_files(
+        all_src_files: list,
+        known_incdir_paths: list,
+        target: str = '',
+        warnings: bool = True,
+        modify_files_and_save_to_path: str = '',
+        unmodified_files_copy_to_path: str = ''
+) -> list:
     ''' Given a list of all_src_files, and list of known_incdir_paths, returns a list
     of all included files (fullpath). This is recurisve if an included file includes another file.
 
@@ -213,7 +266,7 @@ def get_list_sv_included_files(all_src_files:list, known_incdir_paths:list, targ
     # order shouldn't matter, these will get added to the testrunner's filelist and
     # be included with +incdir+.
 
-    sv_included_files_dict = dict() # key, value is if we've traversed it (bool)
+    sv_included_files_dict = {} # key, value is if we've traversed it (bool)
 
     for fname in all_src_files:
         included_files_list = find_sv_included_files_within_file(
@@ -228,7 +281,7 @@ def get_list_sv_included_files(all_src_files:list, known_incdir_paths:list, targ
             if f not in sv_included_files_dict:
                 sv_included_files_dict[f] = False # add entry, mark it not traversed.
 
-    for _ in range(_include_iteration_max_depth):
+    for _ in range(SV_INCLUDE_ITERATION_MAX_DEPTH):
         # do these for a a depth of recurisve levels, in case `include'd file includes another file.
         # If we have more than N levels of `include hunting, then rethink this.
         # For example, some codebases would do their file dependencies as `include
@@ -251,11 +304,11 @@ def get_list_sv_included_files(all_src_files:list, known_incdir_paths:list, targ
     if not all(sv_included_files_dict.values()):
         # we had some that we're traversed.
         not_traversed = [k for k,v in sv_included_files_dict.items() if not v]
-        error(f'Depth {_include_iteration_max_depth=} exceeded in looking for `includes,' \
+        error(f'Depth {SV_INCLUDE_ITERATION_MAX_DEPTH=} exceeded in looking for `includes,' \
               + f' {target=} {not_traversed=}')
 
 
-    ret = list()
+    ret = []
     for fname,traversed in sv_included_files_dict.items():
         if traversed:
             # add all the included files (should be traversed!) to our return list
@@ -265,6 +318,11 @@ def get_list_sv_included_files(all_src_files:list, known_incdir_paths:list, targ
 
 
 class ExportHelper:
+    '''ExportHelper is an object that command handlers can use to assist in creating
+
+    a directory with all exported sources, args, incdirs, defines, and output of
+    what was exported.
+    '''
 
     def __init__(self, cmd_design_obj, eda_command='export', out_dir=None, target=''):
         self.cmd_design_obj = cmd_design_obj
@@ -273,19 +331,21 @@ class ExportHelper:
         self.target = target
 
         self.args = self.cmd_design_obj.args # lazy alias.
-        self.included_files = list()
+        self.included_files = []
         self.out_deps_file = None
 
-        # TODO(drew) It would be neat if I could export an "eda multi" command, like
-        # CommandMulti that only gave me the list of all targets from a wildcard?
-        # Because then I could create exports for each individual target, but lump
-        # all files together and have a single exported DEPS.yml with unique targets.
 
-    def run(self, check_if_overwrite:bool=False,
-              deps_file_args:list=list(),
-              export_json_eda_config:dict=dict(), **kwargs):
+    def run(
+            self, check_if_overwrite:bool=False,
+            deps_file_args:list=[],
+            export_json_eda_config:dict={}, **kwargs
+    ) -> None:
+        '''main entrypoint for ExportHelper object. Creates output directory, writes files
 
-        self.make_out_dir(check_if_overwrite)
+        to it, creates a DEPS.yml in output directory, and optional output JSON file
+        '''
+
+        self.create_out_dir(check_if_overwrite)
         self.write_files_to_out_dir()
         self.create_deps_yml_in_out_dir(deps_file_args=deps_file_args)
 
@@ -295,8 +355,16 @@ class ExportHelper:
         info(f'export_helper: done - wrote to: {self.out_dir}')
 
 
-    def make_out_dir(self, check_if_overwrite:bool=False):
-        assert self.args.get('top', ''), f'Need "top" to be set'
+    def create_out_dir(self, check_if_overwrite: bool= False) -> None:
+        '''Creates output directory for exported files, requires a 'top' to be
+
+        set by the original target, or inferred from target or files.
+        '''
+
+        if not self.args.get('top', ''):
+            error('export_helper.py internal error, args[top] is not set, cannot create',
+                  'output directory for export',
+                  f'{self.args=} {self.target=} {self.eda_command=} {self.out_dir=}')
 
         if not self.out_dir:
             if self.args.get('output', '') == "":
@@ -304,13 +372,20 @@ class ExportHelper:
 
         if check_if_overwrite and self.args.get('force', False):
             if os.path.exists(self.out_dir):
-                util.error(f"export_helper: output directory {out_dir} exists, use --force to overwrite")
+                error(f"export_helper: output directory {self.out_dir} exists, use --force",
+                      "to overwrite")
 
         if not os.path.exists(self.out_dir):
             info(f"export_helper: Creating {self.out_dir} for exported file tree")
             util.safe_mkdir(self.out_dir)
 
+
     def write_files_to_out_dir(self):
+        '''Called by self.run(), writes all files to output directory. Has to determine
+
+        the includes files used by SV/Verilog to unravel nested or relative included
+        paths.
+        '''
 
         # Also sets our list of included files.
         self.included_files = get_list_sv_included_files(
@@ -328,7 +403,9 @@ class ExportHelper:
             if not os.path.exists(dst):
                 shutil.copy(src=filename, dst=dst)
 
-    def create_deps_yml_in_out_dir(self, deps_file_args:list=list()):
+
+    def create_deps_yml_in_out_dir(self, deps_file_args:list=[]):
+        '''Creates ouput exported directory DEPS.yml file with the exported target'''
         if not self.target:
             self.target = 'test'
         else:
@@ -339,7 +416,7 @@ class ExportHelper:
         info(f'export_helper: Creating DEPS.yml for {self.target=} in {self.out_dir=}')
 
         # Need to strip path information from our files_sv and files_v:
-        deps_files = list()
+        deps_files = []
         for fullpath in self.cmd_design_obj.files_sv + self.cmd_design_obj.files_v:
             filename = os.path.split(fullpath)[1]
             deps_files.append(filename)
@@ -361,7 +438,7 @@ class ExportHelper:
 
         if self.cmd_design_obj.defines:
             data[self.target]['defines'] = self.cmd_design_obj.defines.copy()
-            for define in _remove_DEPS_yml_defines:
+            for define in REMOVE_DEPS_YML_DEFINES:
                 # Remove defines keys for OC_ROOT and OC_SEED. Change OC_SEED to _ORIG_OC_SEED
                 if define in data[self.target]['defines']:
                     data[self.target]['defines'].pop(define)
@@ -369,7 +446,7 @@ class ExportHelper:
         reqs_fullpath_list = self.included_files + self.cmd_design_obj.files_non_source
         if reqs_fullpath_list:
             # Need to strip path information from non-source files:
-            data[self.target]['reqs'] = list()
+            data[self.target]['reqs'] = []
             for fullpath in reqs_fullpath_list:
                 filename = os.path.split(fullpath)[1]
                 data[self.target]['reqs'].append(filename)
@@ -377,10 +454,13 @@ class ExportHelper:
 
         dst = os.path.join(self.out_dir, 'DEPS.yml')
         self.out_deps_file = dst
-        util.yaml_safe_writer(data=data, filepath=dst)
+        yaml_safe_writer(data=data, filepath=dst)
 
 
-    def create_export_json_in_out_dir(self, eda_config:dict=dict(), **kwargs):
+    def create_export_json_in_out_dir( # pylint: disable=unused-argument
+            self, eda_config:dict={}, **kwargs
+    ) -> None:
+        '''Optionally creates an exported JSON file in the output directory'''
 
         if not self.eda_command:
             return
@@ -396,17 +476,17 @@ class ExportHelper:
                 'multi': False, # Not yet implemented.
                 'command': self.eda_command,
                 'targets': [self.target],
-                'args': list(),
+                'args': [],
                 'waves': self.args.get('waves', False),
                 # tool - eda.CommandSimVerilator has this set in self.args:
                 'tool': self.args.get('tool', None),
             },
-            'files': list(),
+            'files': [],
         }
 
         # allow caller to override eda - tool, or eda - args, etc.
         for k,v in eda_config.items():
-            if k in data['eda'].keys() and v is not None:
+            if k in data['eda'] and v is not None:
                 data['eda'][k] = v
 
         # Note that args may already be set via:
@@ -434,10 +514,10 @@ class ExportHelper:
             if os.path.exists(out_dir_filename):
                 somefile = out_dir_filename
             else:
-                raise(f'export.json: {self.target=} Missing exported file, orig: {somefile=}')
+                error(f'export.json: {self.target=} Missing exported file, orig: {somefile=}')
 
             assert os.path.exists(somefile)
-            with open(somefile) as f:
+            with open(somefile, encoding='utf-8') as f:
                 filestr = ''.join(f.readlines())
                 data['files'].append({
                     'name': os.path.split(somefile)[1],
@@ -446,7 +526,7 @@ class ExportHelper:
 
 
         dst = os.path.join(self.out_dir, 'export.json')
-        with open(dst, 'w') as f:
+        with open(dst, 'w', encoding='utf-8') as f:
             json.dump(data, f)
             f.write('\n')
         info(f'export_helper: Wrote {dst=}')

opencos/export_json_convert.py

@@ -1,53 +1,60 @@
+'''Converts eda style export.json or export.jsonl to an alternate schema.'''
 
-'''Converts eda style export.json or export.jsonl to a format suitable for test runner schema.'''
-
-import uuid
-import json
-import yaml
 import argparse
-import sys
+import json
 import os
+import sys
+import uuid
 
-def convert(
-        input_json_fname: str,
-        output_json_fname: str,
-        correlation_ids: list = [],
-        output_top_is_eda_target_name:bool = False
-) -> None:
+import yaml
 
+def read_input_json_fname(input_json_fname: str) -> list:
+    '''Returns list (or tests) from input JSON or JSONL, helper function used by convert(...)'''
     data = None
-    new_tests_list = list()
     assert os.path.exists(input_json_fname), f'{input_json_fname=} does not exist'
-    with open(input_json_fname) as f:
+    with open(input_json_fname, encoding='utf-8') as f:
 
         if input_json_fname.lower().endswith('.jsonl'):
-            data = list()
+            data = []
             for line in f.readlines():
                 if line.rstrip():
                     data.append(json.loads(line.rstrip()))
         else:
             data = json.load(f)
 
-    if type(data) is dict and 'eda' in data:
+    if isinstance(data, dict) and 'eda' in data:
         # 1 test, make it a list:
         data = [data]
-    elif type(data) is dict and 'tests' in data and type(data['tests'])  is list:
+    elif isinstance(data, dict) and 'tests' in data and isinstance(data['tests'], list):
         data = data['tests']
 
+    assert data is not None and isinstance(data, list), f'unknown schmea for {input_json_fname=}'
+    return data
 
-    assert data is not None and type(data) is list, f'unknown schmea for {input_json_fname=}'
+
+def convert( # pylint: disable=dangerous-default-value, too-many-locals
+        input_json_fname: str,
+        output_json_fname: str,
+        correlation_ids: list = [],
+        correlation_id_key: str = 'correlation_id',
+        output_top_is_eda_target_name:bool = False
+) -> None:
+    '''Returns None, takes an input json filename, writes to output_json_fname'''
+
+    data = read_input_json_fname(input_json_fname)
+    new_tests_list = []
 
     for index,test in enumerate(data):
 
         if correlation_ids and index < len(correlation_ids):
             correlation_id = correlation_ids[index]
         else:
-            correlation_id = str(uuid.uuid4())
+            correlation_id = str(uuid.uuid4()) # somewhat uuid per entry.
 
         new_test_item = {
-            'top': '', # TODO(drew): eventually change to "targets" list
-            'files_list': list(),
-            'correlation_id': correlation_id,
+            'top': '',
+            'files_list': [],
+            correlation_id_key: correlation_id,
         }
 
         assert 'files' in test
@@ -86,11 +93,12 @@ def convert(
         'tests': new_tests_list
     }
 
-    with open(output_json_fname, 'w') as f:
+    with open(output_json_fname, 'w', encoding='utf-8') as f:
         json.dump(new_data, f)
 
     print(f'Wrote: {output_json_fname=}')
 
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(prog='export_json_convert', add_help=True, allow_abbrev=False)
 

opencos/files.py

@@ -37,7 +37,8 @@ def get_source_file(target:str) -> (bool, str, str):
     if '@' in target:
         for p in ALL_FORCED_PREFIXES:
             if p in target:
-                fpath = ''.join(target.split(p)) # essentially just removing the "sv@" or whatever it is
+                # essentially removing the leading "sv@" or whatever prefix.
+                fpath = ''.join(target.split(p))
                 if os.path.isfile(fpath):
                     return True, fpath, FORCE_PREFIX_DICT.get(p)
 

opencos/{oc_cli.py → hw/oc_cli.py}

@@ -19,8 +19,9 @@ import socket
 import serial # maybe at some point, pull this in, as PySerial is pure python.
 import serial.tools.list_ports
 
-from opencos import util, pcie
+from opencos import util
 from opencos import names as opencos_names
+from opencos.hw import pcie
 
 
 util.progname_in_message = False # too noise for this use case
@@ -2552,7 +2553,7 @@ def main(*args):
     #port = "COM1" if os.name == 'nt' else "/dev/ttyUSB2"
     port = None
     pcie = None
-    for opt,arg in opts:
+    for opt, arg in opts:
         if opt in ['-h', '--help']:
             return usage(do_exit=False, error_code=0)
         if opt in ['-p', '--pcie']:
@@ -2561,8 +2562,12 @@ def main(*args):
             port = arg
         if opt in ['-b', '--baud']:
             baud = arg
-        if util.process_token(opt):
-            if arg: util.proces_token(arg)
+        if opt:
+            # attempt to process util args individually:
+            if arg:
+                util.process_token([opt, arg])
+            else:
+                util.process_token([opt])
 
     if port == None and pcie == None and getpass.getuser() == 'root':
         # we have not been given a connection method, infer the best one

opencos/names.py

@@ -1,7 +1,3 @@
-#!/usr/bin/python3
-
-# SPDX-License-Identifier: MPL-2.0
-
 ''' names.py
 
 This is a human-maintained but ideally machine parsable mapping of names