opencos-eda 0.3.11__tar.gz → 0.3.13__tar.gz

{opencos_eda-0.3.11/opencos_eda.egg-info → opencos_eda-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.3.11
+Version: 0.3.13
 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
@@ -20,7 +20,6 @@ Requires-Dist: supports_color>=0.2.0
 Provides-Extra: dev
 Requires-Dist: pylint>=3.0.0; extra == "dev"
 Requires-Dist: pytest>=8.3.5; extra == "dev"
-Requires-Dist: twine>=6.1.0; extra == "dev"
 Provides-Extra: cocotb
 Requires-Dist: cocotb>=2.0; extra == "cocotb"
 Requires-Dist: pytest>=8.3.5; extra == "cocotb"

opencos_eda-0.3.13/opencos/commands/flist.py

@@ -0,0 +1,413 @@
+'''opencos.commands.flist - Base class command handler for: eda flist ...
+
+Intended to be overriden by Tool based classes (such as CommandFListVivado, etc).'''
+
+# pylint: disable=too-many-branches
+# pylint: disable=too-many-statements
+
+import os
+import shlex
+
+from opencos import util, eda_config
+from opencos.eda_base import CommandDesign, Tool
+from opencos.utils.str_helpers import strip_all_quotes
+from opencos.commands.sim import parameters_dict_get_command_list
+from opencos.utils.str_helpers import strip_outer_quotes
+
+class CommandFList(CommandDesign):
+    '''Base class command handler for: eda flist ...'''
+
+    command_name = 'flist'
+
+    def __init__(self, config: dict):
+        CommandDesign.__init__(self, config=config)
+
+        # If there's no tool attached, then we'll assume this flist is being created
+        # to run in `eda`, not some vendor tool.
+        self.flist_has_tool = isinstance(self, Tool)
+
+        self.flist_args = {
+            'out'                : "flist.out",
+            'emit-define'        : True,
+            'emit-parameter'     : True,
+            'emit-incdir'        : True,
+            'emit-plusargs'      : True,
+            'emit-v'             : True,
+            'emit-sv'            : True,
+            'emit-vhd'           : True,
+            'emit-cpp'           : True,
+            'emit-non-sources'   : True, # as comments, from DEPS 'reqs'
+            'emit-eda-args'      : not self.flist_has_tool, # no Tool means flist for eda.
+            'prefix-define'      : "+define+",
+            'prefix-parameter'   : "-G",
+            'prefix-incdir'      : "+incdir+",
+            'prefix-plusargs'    : "+",
+            'prefix-v'           : "",
+            'prefix-sv'          : "",
+            'prefix-vhd'         : "",
+            'prefix-cpp'         : "",
+            'prefix-non-sources' : "", # as comments anyway.
+            # NOTE - the defaults are for creating an flist that is suitable for 'eda', which for
+            # defines means: optionally single-quote the entire thing, double-quote string values
+            # only.
+            # Tool classes should override if they want to set safe-mode-defines=True.
+            # Tool classes may also avoid these args entirely in their derived CommandFList class
+            'safe-mode-defines'   : not self.flist_has_tool, # no Tool
+            'bracket-quote-define': False,
+            'single-quote-define': False,
+            'quote-define'       : self.flist_has_tool, # Tool, this is NOT for eda.
+            'equal-define'       : True,
+            'escape-define-value': False,
+            'quote-define-value' : False,
+            'bracket-quote-path' : False,
+            'single-quote-path'  : False,
+            'double-quote-path'  : False,
+            'quote-path'         : True,
+            'build-script'       : "", # we don't want this to error either
+
+            'print-to-stdout': False,
+
+            # ex: eda flist --print-to-stdout --emit-rel-path --quiet <target>
+            'emit-rel-path'  : False,
+        }
+
+
+        self.args.update({
+            'eda-dir'            : 'eda.flist', # user can specify eda-dir if files are generated.
+        })
+        self.args.update(self.flist_args)
+
+        self.args_help.update({
+            'print-to-stdout': "do not save file, print to stdout",
+        })
+
+    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.stop_process_tokens_before_do_it():
+            return unparsed
+
+        self.do_it()
+        return unparsed
+
+    def get_flist_dict(self) -> dict:
+        '''Returns dict of some internal class member vars, ignores args
+
+        Useful for an external caller to get details about this CommandDesign child
+        object without generating a .f file, or having to know specifics about the
+        class
+        '''
+        self.command_safe_set_tool_defines() # (Command.command_safe_set_tool_defines)
+
+        ret = {}
+        for key in ['files_sv', 'files_v', 'files_vhd', 'defines', 'incdirs',
+                    'parameters', 'unprocessed-plusargs']:
+            # These keys must exist, all are lists, defines is a dict
+            x = getattr(self, key, None)
+            if isinstance(x, (dict, list)):
+                ret[key] = x.copy()
+            else:
+                ret[key] = x
+        return ret
+
+    def get_flist_defines_list(self) -> list:
+        '''Returns formatted list of str for known defines'''
+
+        ret = []
+        prefix = strip_all_quotes(self.args['prefix-define'])
+        for d, value in self.defines.items():
+
+            if value is None:
+                ret.append(prefix + d)
+                continue
+
+            # else, value exists:
+            safe_mode_guard_str_value = bool(
+                self.args['safe-mode-defines'] and isinstance(value, str) and ' ' in value
+            )
+
+            if self.args['bracket-quote-define']:
+                qd1 = "{"
+                qd2 = "}"
+            elif self.args['single-quote-define']:
+                qd1 = "'"
+                qd2 = "'"
+            elif self.args['quote-define']:
+                qd1 = '"'
+                qd2 = '"'
+            else:
+                qd1 = ''
+                qd2 = ''
+
+            if self.args['equal-define']:
+                ed1 = '='
+            else:
+                ed1 = ' '
+
+            if self.args['escape-define-value']:
+                value = value.replace('\\', '\\\\').replace('"', '\\"')
+            if self.args['quote-define-value']:
+                value = '"' + value + '"'
+            if safe_mode_guard_str_value:
+                value = strip_outer_quotes(value.strip('\n'))
+                value = '"' + value + '"'
+
+            if self.args['quote-define'] and value.startswith('"') and value.endswith('"'):
+                # If you wanted your define to look like:
+                # +define+"NAME=VALUE", but VALUE also has double quotes wrapping it,
+                # it's unlikely to work so we'll optimistically so escape the " wrapping value.
+                # If you have additional " in the middle of the value, good luck.
+                value = '\\"' + value[1:-1] + '\\"'
+
+            newline = prefix + qd1 + f"{d}{ed1}{value}" + qd2
+
+            if safe_mode_guard_str_value:
+                # wrap the entire thing with single-quotes, so it survives as a single
+                # token in an eda dot-f file:
+                newline = shlex.quote(newline)
+
+            ret.append(newline)
+
+        return ret
+
+    def get_flist_plusargs_list(self) -> list:
+        '''Returns formatted list of str for unprocessed plusargs
+
+        Tool based classes can override if they also want to query their own
+        processed plusargs, such as CommandSim.args[sim-plusargs']
+        '''
+        ret = []
+        for x in self.args.get('unprocessed-plusargs', []) + self.args.get('sim-plusargs', []):
+            if self.args['prefix-plusargs']:
+                if x.startswith('+'):
+                    x = x[1:] # strip leading +
+                x = self.args['prefix-plusargs'] + x
+            ret.append(x)
+        return ret
+
+    def get_flist_parameter_list(self) -> list:
+        '''Returns formatted list of str for parameters'''
+        prefix = strip_all_quotes(self.args['prefix-parameter'])
+        return parameters_dict_get_command_list(
+                params=self.parameters, arg_prefix=prefix, for_flist=True
+        )
+
+    def get_flist_eda_args_list(self) -> list:
+        '''Returns list of eda args for an eda-capable flist
+
+        - This will NOT add any util based args (--color | --no-color, --debug, etc)
+        - This will NOT add any -f/--input-file args (those are already resolved)
+
+        - This WILL add --env-file args
+        - This WILL add --config-yml args that were not default value
+
+        Not intended to be overriden by Tool based command classes.
+        '''
+        ret = []
+
+        # --env-file(s), if used:
+        for env_file in util.env_files_loaded:
+            ret.append(f'--env-file={env_file}')
+
+        # --config-yml, if non-default:
+        ret.extend(eda_config.get_config_yml_args_for_flist())
+
+        # EDA args, but not the flist specific args, and only those that were modified.
+        for arg, _ in self.modified_args.items():
+
+            if arg in self.flist_args:
+                # do not emit flist command args
+                continue
+
+            value = self.args[arg]
+            if isinstance(value, bool):
+                if value:
+                    ret.append(f'--{arg}')
+                else:
+                    ret.append(f'--no-{arg}')
+            else:
+                ret.append(f'--{arg}={value}')
+        return ret
+
+    def get_additional_flist_args_list(self) -> list:
+        '''Derived classes may override, to output additional args in the flist'''
+        return []
+
+    def get_additional_flist_files_list(self) -> list:
+        '''Derived classes may override, to output additional files in the flist'''
+        return []
+
+
+    def do_it(self) -> None:
+        '''do_it() is the main entry point for creating the flist(),
+
+        Usually it is called from self.process_tokens()'''
+
+        # add defines for this job
+        self.command_safe_set_tool_defines() # (Command.command_safe_set_tool_defines)
+
+        if not self.args['top']:
+            util.warning(f'CommandFList: {self.command_name=} not run due to lack of',
+                         f'{self.args["top"]=} value')
+            self.write_eda_config_and_args()
+            return
+
+        if self.config['tool']:
+            tool_string = f' (with --tool={self.config["tool"]})'
+        else:
+            tool_string = ''
+
+        # if config['tool'] is set, but self.flist_has_tool is False, we're likely using
+        # this default handler CommandFList and the Tool class hasn't defined what they
+        # do. In this case, simply warn that this will emit a non-tool specific default flist
+        # intended for use by `eda`:
+        if self.config['tool'] and not self.flist_has_tool:
+            util.warning(f'For command="flist"{tool_string}, there is no tool',
+                         'specific handler for producing an flist. The default eda flist will',
+                         'be emitted')
+            # If this happens, you'll likely want the Tool based defines (that were never set
+            # by Tool.set_tool_defines(self) b/c we have no Tool class.
+            # TODO(drew): This is only a best-effort, we could create a derived Tool object and
+            # instead call obj.set_tool_defines(), and update self.defines instead?
+            _tool_config = self.config.get('tools', {}).get(self.config['tool'], {})
+            self.defines.update(
+                _tool_config.get('defines', {})
+            )
+
+
+
+        # check if we're overwriting the output flist file.
+        if self.args['print-to-stdout']:
+            pass
+        elif os.path.exists(self.args['out']):
+            if self.args['force']:
+                util.info(f"Removing existing {self.args['out']}")
+                os.remove(self.args['out'])
+            else:
+                self.error(f"Not overwriting {self.args['out']} unless you specify --force")
+
+        # Note - we create a work_dir in case any DEPS commands created files that need to be
+        # added to our sources.
+        self.create_work_dir()
+        self.run_dep_commands()
+
+        pq1 = ""
+        pq2 = "" # pq = path quote
+        if not self.args['quote-path']:
+            pass # if we decide to make one of the below default, this will override
+        elif self.args['bracket-quote-path']:
+            pq1 = "{"
+            pq2 = "}"
+        elif self.args['single-quote-path']:
+            pq1 = "'"
+            pq2 = "'"
+        elif self.args['double-quote-path']:
+            pq1 = '"'
+            pq2 = '"'
+
+        if self.args['print-to-stdout']:
+            fo = None
+            print()
+        else:
+            util.debug(f"Opening {self.args['out']} for writing")
+            fo = open( # pylint: disable=consider-using-with
+                self.args['out'], 'w', encoding='utf-8'
+            )
+            print(f"## {self.args=}", file=fo)
+
+            if self.args['emit-non-sources']:
+                if self.files_non_source:
+                    print('## reqs (non-source files that are dependencies):', file=fo)
+                    prefix = strip_all_quotes(self.args['prefix-non-sources'])
+                    for f in self.files_non_source:
+                        if self.args['emit-rel-path']:
+                            f = os.path.relpath(f)
+                        print('##    ' + prefix + pq1 + f + pq2, file=fo)
+
+        if self.args['emit-eda-args']:
+            for newline in self.get_flist_eda_args_list():
+                print(newline, file=fo)
+
+        defines_lines = self.get_flist_defines_list()
+        if not self.args['emit-define'] and defines_lines:
+            util.warning(f'Command "flist"{tool_string}, has defines present but they were not',
+                         f'included in the output flist: {defines_lines}')
+
+        parameter_lines = self.get_flist_parameter_list()
+        if not self.args['emit-parameter'] and parameter_lines:
+            util.warning(f'Command "flist"{tool_string}, has parameters present but they were not',
+                         f'included in the output flist: {parameter_lines}')
+
+        plusarg_lines = self.get_flist_plusargs_list()
+        if not self.args['emit-plusargs'] and plusarg_lines:
+            util.warning(f'Command "flist"{tool_string}, has plusargs present but they were not',
+                         f'included in the output flist: {plusarg_lines}')
+
+        if self.args['emit-define']:
+            for newline in defines_lines:
+                print(newline, file=fo)
+
+        if self.args['emit-parameter']:
+            for newline in parameter_lines:
+                print(newline, file=fo)
+
+
+        if self.args['emit-incdir']:
+            prefix = strip_all_quotes(self.args['prefix-incdir'])
+            for i in self.incdirs:
+                if self.args['emit-rel-path']:
+                    i = os.path.relpath(i)
+                print(prefix + pq1 + i + pq2, file=fo)
+
+        if self.args['emit-plusargs']:
+            for newline in plusarg_lines:
+                print(newline, file=fo)
+
+
+        # Hook for derived classes to optionally print additional custom args, prior to
+        # any files:
+        for newline in self.get_additional_flist_args_list():
+            print(newline, file=fo)
+
+        if self.args['emit-v']:
+            prefix = strip_all_quotes(self.args['prefix-v'])
+            for f in self.files_v:
+                if self.args['emit-rel-path']:
+                    f = os.path.relpath(f)
+                print(prefix + pq1 + f + pq2, file=fo)
+
+        if self.args['emit-sv']:
+            prefix = strip_all_quotes(self.args['prefix-sv'])
+            for f in self.files_sv:
+                if self.args['emit-rel-path']:
+                    f = os.path.relpath(f)
+                print(prefix + pq1 + f + pq2, file=fo)
+        if self.args['emit-vhd']:
+            prefix = strip_all_quotes(self.args['prefix-vhd'])
+            for f in self.files_vhd:
+                if self.args['emit-rel-path']:
+                    f = os.path.relpath(f)
+                print(prefix + pq1 + f + pq2, file=fo)
+        if self.args['emit-cpp']:
+            prefix = strip_all_quotes(self.args['prefix-cpp'])
+            for f in self.files_cpp:
+                if self.args['emit-rel-path']:
+                    f = os.path.relpath(f)
+                print(prefix + pq1 + f + pq2, file=fo)
+
+        # Hook for derived classes to optionally print additional flist items after
+        # any files:
+        for newline in self.get_additional_flist_files_list():
+            print(newline, file=fo)
+
+        if self.args['print-to-stdout']:
+            print() # don't need to close fo (None)
+        else:
+            fo.close()
+            util.info(f"Created file: {self.args['out']}")
+
+        self.write_eda_config_and_args()
+        self.run_post_tool_dep_commands()

{opencos_eda-0.3.11 → opencos_eda-0.3.13}/opencos/commands/multi.py

@@ -281,7 +281,7 @@ class CommandMulti(CommandParallel):
         if parsed.parallel < 1 or parsed.parallel > 256:
             self.error("Arg 'parallel' must be between 1 and 256")
 
-        command = self.get_command_from_unparsed_args(tokens=unparsed)
+        command = self.get_sub_command_from_config()
 
         # Need to know the tool for this command, either it was set correctly via --tool and/or
         # the command (class) will tell us.
@@ -354,9 +354,11 @@ class CommandMulti(CommandParallel):
 
         if self.args['print-targets']:
             util.info('Multi print-targets (will not run jobs): -->')
-            for t in self.targets:
+            print_targets = [t[0] for t in self.targets]
+            print_targets.sort()
+            for x in print_targets:
                 # t = tuple of (target:str, tool:str), we just want the target.
-                print(f'  {t[0]}')
+                print(f'  {x}')
         else:
             util.debug("Multi: converting list of targets into list of jobs")
             self.jobs = []

{opencos_eda-0.3.11 → opencos_eda-0.3.13}/opencos/commands/sim.py

@@ -12,15 +12,32 @@ Note that CommandSim is also a base class for opencos.commands.elab.CommandElab.
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 
 import os
+import shlex
 
 from opencos import util, export_helper
 from opencos.eda_base import CommandDesign, Tool
 from opencos.utils import status_constants
 
-from opencos.utils.str_helpers import sanitize_defines_for_sh, strip_outer_quotes
+from opencos.utils.str_helpers import strip_outer_quotes
 
-def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> list:
-    '''Given dict of parameters, returns a command list'''
+def parameters_dict_get_command_list(
+        params: dict, arg_prefix: str = '-G',
+        hier_delimiter: str = '.',
+        top_hier_str: str = '',
+        for_flist: bool = False
+) -> list:
+    '''Given dict of parameters, returns a command list.
+
+    Some simulators will set ALL parameters with Name=Value at all levels of hierarchy,
+    so to avoid that and only set top level parameters, but still allow package or
+    hierarchy parameters to be set, you can use:
+
+    hier_delimiter='/'
+    top_hier_str=f'/{TOP_MODULE_NAME}/'
+
+    Which will, if a parameter Name does not contain the heir delimiter, the Name
+    will be prepended with top_hier_str.
+    '''
 
     ret_list = []
     if ' ' in arg_prefix:
@@ -34,13 +51,29 @@ def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> li
         if not isinstance(v, (int, str)):
             util.warning(f'parameter {k} has value: {v}, parameters must be int/string types')
 
+        if top_hier_str and hier_delimiter not in k:
+            k = f'{top_hier_str}{k}'
+
         ret_list.extend(arg_list_prefix)
         if isinstance(v, int):
             ret_list.append(f'{arg_str_prefix}{k}={v}')
         else: # string
+            # Note if for_flist=True, then we have to take extra care on what gets
+            # double-quotes " and \".
             v = strip_outer_quotes(v.strip('\n'))
             v = '"' + v + '"'
-            ret_list.append(f'{arg_str_prefix}{k}={sanitize_defines_for_sh(v)}')
+
+            if for_flist:
+                # do not wrap with " unless there are spaces, if there are spaces
+                # wrap the entire thing with single quotes (bash)
+                if ' ' in v:
+                    ret_list.append(shlex.quote(f'{arg_str_prefix}{k}={v}'))
+                else:
+                    ret_list.append(f'{arg_str_prefix}{k}={v}')
+            else:
+                # This is for a tool, so simply guard single quotes:
+                v = v.replace("'", "\\" + "'")
+                ret_list.append(f'{arg_str_prefix}{k}={v}')
     return ret_list
 
 
@@ -79,6 +112,8 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             # not used by other simulators, so these can go in DEPS files for custom things
             # like -CFLAGS -O0, etc.
             'verilate-args': [],
+            'ext-defines-sv-fname': '',
+            'license-queue': False,
         })
         self.args_help.update({
             'pre-sim-tcl': (
@@ -124,6 +159,15 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             'uvm-version': (
                 'Used if --uvm is set, for example --uvm-version=1.2'
             ),
+            'ext-defines-sv-fname': (
+                'If set to empty str, --ext-defines-sv-fname="", applies defines to tool via args.'
+                ' If set to non-emtpy str as a .sv file name, such as'
+                ' --ext-defines-sv-fname=_ext_defines.sv, saves defines to a file name in the'
+                ' work-dif, and adds this file to the SV/Verilog file list ahead of other files.'
+            ),
+            'license-queue': (
+                'Set to enable env vars LICENSE_QUEUE=1 which has effects on certain simulators'
+            ),
 
         })
 
@@ -133,9 +177,24 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
 
 
 
-    def process_parameters_get_list(self, arg_prefix: str = '-G') -> list:
-        '''Returns list (suitable command list for shell or for tool) from self.parameters'''
-        return parameters_dict_get_command_list(params=self.parameters, arg_prefix=arg_prefix)
+    def process_parameters_get_list(
+            self, arg_prefix: str = '-G', **kwargs
+    ) -> list:
+        '''Returns list (suitable command list for shell or for tool) from self.parameters
+
+        Some simulators will set ALL parameters with Name=Value at all levels of hierarchy,
+        so to avoid that and only set top level parameters, but still allow package or
+        hierarchy parameters to be set, you can use args (in kwargs):
+
+        hier_delimiter='/'
+        top_hier_str=f'/{TOP_MODULE_NAME}/'
+
+        Which will, if a parameter Name does not contain the heir delimiter, the Name
+        will be prepended with top_hier_str.
+        '''
+        return parameters_dict_get_command_list(
+            params=self.parameters, arg_prefix=arg_prefix, **kwargs
+        )
 
     def process_plusarg(self, plusarg: str, pwd: str = os.getcwd()) -> None:
         '''Override for CommandDesign.process_plusarg(..)'''
@@ -159,6 +218,8 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
         if self.stop_process_tokens_before_do_it():
             return unparsed
 
+        self.handle_arg_license_queue()
+
         # add defines for this job type
         if self.args['lint'] or self.args['stop-after-elaborate']:
             self.args['lint'] = True
@@ -572,3 +633,56 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             search_paths=self.args['work-dir'], file_extension='vcd',
             typ='waveform', description='Simulation Waveform VCD (Value Change Dump) file'
         )
+
+
+    def create_ext_defines_sv(self) -> None:
+        '''Creates _ext_defines.sv in the work-dir, adds to front of self.files_sv'''
+
+        if not self.defines:
+            return
+
+        if not self.args['ext-defines-sv-fname']:
+            return
+
+        fpath = os.path.join(self.args['work-dir'], self.args['ext-defines-sv-fname'])
+        fpath_abs = os.path.abspath(fpath)
+        if fpath_abs in self.files:
+            util.warning(f'{fpath} already exists, will overwrite. Consider changing the value',
+                         f'of arg: --ext-defines-sv-fname={self.args["ext-defines-sv-fname"]}')
+        if not fpath.endswith('.sv') and not fpath.endswith('.v'):
+            util.error(f'--ext-defines-sv-fname={self.args["ext-defines-sv-fname"]} must end with',
+                       '.v or .sv')
+            return
+
+        ifdef_guard = os.path.split(self.args['ext-defines-sv-fname'])[1].upper()
+        ifdef_guard = ifdef_guard.replace('.', '__').replace('/', '__')
+        with open(fpath, 'w', encoding='utf-8') as f:
+            f.write(f'`ifndef {ifdef_guard}\n')
+            f.write(f'`define {ifdef_guard}\n')
+            f.write('\n')
+            for key, value in self.defines.items():
+                if value is None:
+                    f.write(f'`define {key}\n')
+                else:
+                    # if the value v is a double-quoted string, such as v='"hi"' that needs
+                    # to be preserved.
+                    f.write(f'`define {key} {value}\n')
+
+            f.write('\n')
+            f.write(f'`endif // {ifdef_guard}\n')
+
+        self.files_sv.insert(0, fpath_abs)
+        self.files[fpath_abs] = True
+        self.files_caller_info[fpath_abs] = (
+            'opencos.commands.sim::CommandSim::create_ext_defines_sv'
+        )
+        util.info(f'command "sim": {fpath} created for defines: {list(self.defines.keys())}')
+
+
+    def handle_arg_license_queue(self) -> None:
+        '''Handles self.args['license-queue'] (bool) to set env vars'''
+        if not self.args['license-queue']:
+            return
+
+        if 'LICENSE_QUEUE' not in os.environ:
+            os.environ['LICENSE_QUEUE'] = '1'

{opencos_eda-0.3.11 → opencos_eda-0.3.13}/opencos/commands/sweep.py

@@ -72,7 +72,7 @@ class CommandSweep(CommandDesign, CommandParallel):
 
         self.check_args()
 
-        self.single_command = self.get_command_from_unparsed_args(tokens=unparsed)
+        self.single_command = self.get_sub_command_from_config()
 
         self._append_sweep_args(arg_tokens=arg_tokens)
 

{opencos_eda-0.3.11 → opencos_eda-0.3.13}/opencos/commands/upload.py

@@ -204,9 +204,9 @@ class CommandUpload(Command):
         tool = tools_found.pop() # only item in set
         # Do we have a handler for this in our config?
         if tool in self.config.get('tools_loaded', []):
-            auto_tools_order = self.config.get('auto_tools_order', [{}])[0]
-            if tool in auto_tools_order:
-                cls_str = auto_tools_order[tool].get('handlers', {}).get(self.command_name, None)
+            tool_cfg = self.config.get('tools', {}).get(tool, {})
+            if tool_cfg:
+                cls_str = tool_cfg.get('handlers', {}).get(self.command_name, None)
                 if cls_str:
                     cls = import_class_from_string(cls_str)
                     if issubclass(cls, Command):
@@ -217,5 +217,5 @@ class CommandUpload(Command):
 
         warning(f'No handler found for tool={tool} to process bitfiles: {self.bitfiles}')
         debug(f'config -- tools_loaded: {self.config["tools_loaded"]}')
-        debug(f'config -- auto_tools_order for tool: {self.config["auto_tools_order"][0][tool]}')
+        debug(f'config -- tools for tool: {self.config["tools"].get(tool, "")}')
         return self