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

opencos/deps_schema.py

@@ -133,7 +133,8 @@ import sys
 
 from schema import Schema, Or, Optional, SchemaError
 
-from opencos import util, deps_helpers
+from opencos import util
+from opencos.deps import deps_file
 
 # Because we deal with YAML, where a Table Key with dangling/empty value is allowed
 # and we have things like SystemVerilog defines where there's a Table key with no Value,
@@ -312,21 +313,19 @@ FILE_SIMPLIFIED = Schema(
 
 def check(data: dict, schema_obj=FILE) -> (bool, str):
     '''Returns (bool, str) for checking dict against FILE schema'''
-
-
     try:
         schema_obj.validate(data)
         return True, None
     except SchemaError as e:
-        return False, str(e)
-    except Exception as e: # pylint: disable=broad-exception-caught
+        return False, f'SchemaError: {e}'
+    except Exception as e:
         return False, str(e)
 
 
 def deps_markup_safe_load(deps_filepath: str) -> (bool, dict):
     '''Returns tuple (bool False if took errors, dict of markp data)'''
     current_errors = util.args['errors']
-    data = deps_helpers.deps_markup_safe_load(deps_filepath)
+    data = deps_file.deps_markup_safe_load(deps_filepath)
     if util.args['errors'] > current_errors:
         return False, data
     return True, data
@@ -337,10 +336,10 @@ def check_file(filepath: str, schema_obj=FILE) -> (bool, str, str):
 
     deps_filepath = filepath
     if os.path.isdir(filepath):
-        deps_filepath = deps_helpers.get_deps_markup_file(base_path=filepath)
+        deps_filepath = deps_file.get_deps_markup_file(base_path=filepath)
 
     # get deps file
-    if not os.path.exists(deps_filepath):
+    if not os.path.isfile(deps_filepath):
         print(f'ERROR: internal error(s) no DEPS.[yml|..] found in {filepath=}')
         return False, '', deps_filepath
 

opencos/eda.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 
-# SPDX-License-Identifier: MPL-2.0
+'''opencos.eda is an executable script (as `eda <command> ...`)
+
+This is the entrypoint for tool discovery, and running targets from command line or DEPS
+markup files
+'''
 
 import subprocess
 import os
@@ -13,9 +17,7 @@ import shlex
 import importlib.util
 
 import opencos
-from opencos import util, files
-from opencos import eda_config
-from opencos import eda_base
+from opencos import util, eda_config, eda_base
 from opencos.eda_base import Tool, which_tool
 
 # Configure util:
@@ -46,7 +48,7 @@ def init_config(
         else:
             config['command_handler'][command] = cls
 
-    config['auto_tools_found'] = dict()
+    config['auto_tools_found'] = {}
     config['tools_loaded'] = set()
     if run_auto_tool_setup:
         config = auto_tool_setup(config=config, quiet=quiet, tool=tool)
@@ -55,7 +57,7 @@ def init_config(
 
 
 
-def usage(tokens: list, config: dict, command=""):
+def usage(tokens: list, config: dict, command="") -> int:
     '''Returns an int shell return code, given remaining args (tokens list) and eda command.
 
     config is the config dict. Used to check valid commands in config['command_handler']
@@ -101,41 +103,44 @@ And <files|targets, ...> is one or more source file or DEPS markup file target,
         )
         eda_base.print_base_help()
         return 0
-    elif command in config['command_handler'].keys():
+
+    if command in config['command_handler'].keys():
         sco = config['command_handler'][command](config=config) # sub command object
         sco.help(tokens=tokens)
         return util.exit(0)
-    else:
-        util.info(f"Valid commands are: ")
-        for k in sorted(config['command_handler'].keys()):
-            util.info(f"   {k:20}")
-        return util.error(f"Cannot provide help, don't understand command: '{command}'")
 
-def interactive(config: dict):
-    read_file = False
+    util.info("Valid commands are:")
+    for k in sorted(config['command_handler'].keys()):
+        util.info(f"   {k:20}")
+    return util.error(f"Cannot provide help, don't understand command: '{command}'")
+
+
+def interactive(config: dict) -> int:
+    '''Returns bash/sh return code, entry point for running interactively in CLI if
+
+    args are not present to directly call a command handler, --help, etc
+    '''
+    rc = 0
     while True:
-        if read_file:
-            line = f.readline()
-            if line:
-                print("%s->%s" % (fname, line), end="")
-            else:
-                read_file = False
-                f.close()
-                continue
-        else:
-            line = input('EDA->')
+        line = input('EDA->')
         m = re.match(r'^([^\#]*)\#.*$', line)
-        if m: line = m.group(1)
+        if m:
+            line = m.group(1)
         tokens = line.split()
         original_args = tokens.copy()
         # NOTE: interactive will not correctly handle --config-yml arg (from eda_config.py),
         # but we should do a best effor to re-parse args from util.py, such as
         # --quiet, --color, --fancy, --logfile, --debug or --debug-level, etc
         _, tokens = util.process_tokens(tokens)
-        process_tokens(tokens=tokens, original_args=original_args, config=config, interactive=True)
+        rc = process_tokens(
+            tokens=tokens, original_args=original_args, config=config, is_interactive=True
+        )
+    return rc
 
 
-def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) -> dict:
+def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+        warnings: bool = True, config = None, quiet: bool = False, tool: str = ''
+) -> dict:
     '''Returns an updated config, uses config['auto_tools_order'][0] dict, calls tool_setup(..)
 
     -- adds items to config['tools_loaded'] set
@@ -151,8 +156,8 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
     )
 
     assert 'auto_tools_order' in config
-    assert type(config['auto_tools_order']) is list
-    assert type(config['auto_tools_order'][0]) is dict
+    assert isinstance(config['auto_tools_order'], list)
+    assert isinstance(config['auto_tools_order'][0], dict)
 
     for name, value in config['auto_tools_order'][0].items():
         if tool and tool != name:
@@ -160,12 +165,13 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
 
         util.debug(f"Checking for ability to run tool: {name}")
         exe = value.get('exe', str())
-        if type(exe) is list:
+        if isinstance(exe, list):
             exe_list = exe
-        elif type(exe) is str:
+        elif isinstance(exe, str):
             exe_list = [exe] # make it a list
         else:
-            util.error(f'eda.py: config["auto_tools_order"][0] for {name=} {value=} has bad type for {exe=}')
+            util.error(f'eda.py: config["auto_tools_order"][0] for {name=} {value=} has bad type'
+                       f'for {exe=}')
             continue
 
         has_all_py = True
@@ -201,14 +207,16 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
             for cmd in requires_cmd_list:
                 cmd_list = shlex.split(cmd)
                 try:
-                    proc = subprocess.run(cmd_list, capture_output=True, input=b'exit\n\n')
+                    proc = subprocess.run(cmd_list, capture_output=True, check=False,
+                                          input=b'exit\n\n')
                     if proc.returncode != 0:
                         if not quiet:
-                            util.debug(f"For tool {name} missing required command ({proc.returncode=}): {cmd_list=}")
+                            util.debug(f"For tool {name} missing required command",
+                                       f"({proc.returncode=}): {cmd_list=}")
                         has_all_exe = False
-                except:
+                except Exception as e:
                     has_all_exe = False
-                    util.debug(f"... No, exception running {cmd_list}")
+                    util.debug(f"... No, exception {e} running {cmd_list}")
 
 
         if all([has_all_py, has_all_env, has_all_exe, has_all_in_exe_path]):
@@ -263,12 +271,11 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
         if warnings:
             util.warning(f"tool_setup: {auto_setup=} already setup for {tool}?")
 
-    entry = config['auto_tools_order'][0].get(tool, dict())
-    tool_cmd_handler_dict = entry.get('handlers', dict())
+    entry = config['auto_tools_order'][0].get(tool, {})
+    tool_cmd_handler_dict = entry.get('handlers', {})
 
     for command, str_class_name in tool_cmd_handler_dict.items():
         current_handler_cls = config['command_handler'].get(command, None)
-        ext_mod = None
 
         if auto_setup and current_handler_cls is not None and issubclass(current_handler_cls, Tool):
             # If we're not in auto_setup, then always override (aka arg --tool=<this tool>)
@@ -277,19 +284,28 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
 
         cls = util.import_class_from_string(str_class_name)
 
-        assert issubclass(cls, Tool), f'{str_class_name=} is does not have Tool class associated with it'
+        assert issubclass(cls, Tool), \
+            f'{str_class_name=} is does not have Tool class associated with it'
         util.debug(f'Setting {cls=} for {command=} in config.command_handler')
         config['command_handler'][command] = cls
 
     config['tools_loaded'].add(tool)
 
 
-def process_tokens(tokens: list, original_args: list, config: dict, interactive=False):
-    # this is the top level token processing function.  tokens can come from command line, setup file, or interactively.
-    # we do one pass through all the tokens, triaging them into:
-    # - those we can execute immediate (help, quit, and global opens like --debug, --color)
-    # - a command (sim, synth, etc)
-    # - command arguments (--seed, +define, +incdir, etc) which will be deferred and processed by the command
+def process_tokens( # pylint: disable=too-many-branches,too-many-statements
+        tokens: list, original_args: list, config: dict, is_interactive=False
+) -> int:
+    '''Returns bash/sh style return code int (0 pass, non-zero fail).
+
+    This is the top level token processing function, and entry point (after util and eda_config
+    have performed their argparsing). Tokens can come from command line, DEPS target markup file,
+    or interactively. We do one pass through all the tokens, triaging them into:
+     - those we can execute immediate (help, quit, and global opens like --debug, --color)
+        -- some of this has already been performed in main() by util for --color.
+    - a command (sim, synth, etc)
+    - command arguments (--seed, +define, +incdir, etc) which will be deferred and processed by
+      the command. Some are processed here (--tool)
+    '''
 
     deferred_tokens = []
     command = ""
@@ -329,7 +345,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
             unparsed.remove(value) # remove command (flist, export, targets, etc)
             break
 
-    if not interactive:
+    if not is_interactive:
         # Run init_config() now, we deferred it in main(), but only run it
         # for this tool (or tool=None to figure it out)
         config = init_config(
@@ -337,7 +353,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
             run_auto_tool_setup=run_auto_tool_setup
         )
         if not config:
-            util.error(f'eda.py main: problem loading config, {args=}')
+            util.error(f'eda.py main: problem loading config, {tokens=}')
             return 3
 
     # Deal with help, now that we have the command (if it was set).
@@ -355,9 +371,9 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
         tool_setup(parsed.tool, config=config)
 
     deferred_tokens = unparsed
-    if command == "":
+    if not command:
         util.error("Didn't get a command!")
-        return 1
+        return 2
 
     sco = config['command_handler'][command](config=config) # sub command object
     util.debug(f'{command=}')
@@ -378,16 +394,23 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     # Add the original, nothing-parsed args to the Command.config dict.
     sco.config['eda_original_args'] = original_args
 
-    setattr(sco, 'command_name', command) # as a safeguard, b/c 'command' is not always passed to 'sco'
+    setattr(sco, 'command_name', command) # as a safeguard, 'command' is not always passed to 'sco'
     unparsed = sco.process_tokens(tokens=deferred_tokens, pwd=os.getcwd())
 
-    # query the status from the Command object (0 is pass, > 0 is fail)
-    rc = getattr(sco, 'status', 1)
+    # query the status from the Command object (0 is pass, > 0 is fail, but we'd prefer to avoid
+    # rc=1 because that's the python exception rc)
+    rc = getattr(sco, 'status', 2)
     util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(sco)=}, {unparsed=}')
     return rc
 
 
 def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> int:
+    '''Returns bash/sh return code, checks that a command handling class has all
+
+    internal CHECK_REQUIRES list items. For example, sim.py has CHECK_REQUIRES=[Tool],
+    so if a 'sim' command handler does not also inherit a Tool class, then reports this as an
+    error.
+    '''
     sco = command_obj
     for cls in getattr(sco, 'CHECK_REQUIRES', []):
         if not isinstance(sco, cls):
@@ -405,7 +428,8 @@ def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> i
 # **************************************************************
 # **** Interrupt Handler
 
-def signal_handler(sig, frame):
+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.exit(-1)
@@ -437,6 +461,8 @@ def main(*args):
 
     if not util.args['quiet']:
         util.info(f'eda: version {opencos.__version__}')
+        # And show the command that was run (all args):
+        util.info(f"main: eda {' '.join(args)}; (run from {os.getcwd()})")
 
     # Handle --config-yml= arg
     config, unparsed = eda_config.get_eda_config(unparsed)
@@ -449,15 +475,16 @@ def main(*args):
     if len(args) == 0 or (len(args) == 1 and '--debug' in args):
         # special snowflake case if someone called with a singular arg --debug
         # (without --help or exit)
-        util.debug(f"Starting automatic tool setup: init_config()")
+        util.debug("Starting automatic tool setup: init_config()")
         config = init_config(config=config)
         if not config:
             util.error(f'eda.py main: problem loading config, {args=}')
             return 3
         main_ret = interactive(config=config)
     else:
-        main_ret =  process_tokens(tokens=list(unparsed), original_args=original_args,
-                              config=config)
+        main_ret =  process_tokens(
+            tokens=list(unparsed), original_args=original_args, config=config
+        )
     # Stop the util log, needed for pytests that call eda.main directly that otherwise
     # won't close the log file via util's atexist.register(stop_log)
     util.global_log.stop()
@@ -475,10 +502,3 @@ def main_cli() -> None:
 
 if __name__ == '__main__':
     main_cli()
-
-# IDEAS:
-# * options with no default (i.e. if user doesn't override, THEN we set it, like "seed" or "work-dir") can be given a
-#   special type (DefaultVar) versus saying "None" so that help can say more about it (it's a string, it's default val
-#   is X, etc) and it can be queried as to whether it's really a default val.  This avoids having to avoid default vals
-#   that user can never set (-1, None, etc) which make it hard to infer the type.  this same object can be given help
-#   info and simply "render" to the expected type (str, integer, etc) when used.