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

opencos/commands/__init__.py

@@ -17,7 +17,9 @@ from .sweep import CommandSweep
 from .synth import CommandSynth
 from .upload import CommandUpload
 from .waves import CommandWaves
+from .shell import CommandShell
 from .targets import CommandTargets
+from .lec import CommandLec
 
 __all__ = [
     'CommandBuild',
@@ -33,5 +35,7 @@ __all__ = [
     'CommandToolsMulti',
     'CommandUpload',
     'CommandWaves',
+    'CommandShell',
     'CommandTargets',
+    'CommandLec',
 ]

opencos/commands/export.py

@@ -37,7 +37,6 @@ class CommandExport(CommandDesign):
             self, tokens: list, process_all: bool = True, pwd: str = os.getcwd()
     ) -> list:
 
-        self.defines['OC_EXPORT'] = None
         unparsed = CommandDesign.process_tokens(
             self, tokens=tokens, process_all=process_all, pwd=pwd
         )

opencos/commands/flist.py

@@ -47,11 +47,14 @@ class CommandFList(CommandDesign):
             'no-quote-path'      : False,
             'build-script'       : "", # we don't want this to error either
 
-            'print-to-stdout': False, # do not save to file, print to stdout.
+            'print-to-stdout': False,
 
             # ex: eda flist --print-to-stdout --emit-rel-path --quiet <target>
             'emit-rel-path'  : False,
         })
+        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()

opencos/commands/lec.py

@@ -0,0 +1,103 @@
+'''opencos.commands.lec - Base class command handler for: eda lec ...
+
+Intended to be overriden by Tool based classes (such as CommandLecYosys, etc)
+'''
+
+# Note - similar code waiver, tricky to eliminate it with inheritance when
+# calling reusable methods.
+# pylint: disable=R0801
+
+import os
+
+from opencos import eda_extract_targets
+from opencos.eda_base import CommandDesign, Tool
+
+
+class CommandLec(CommandDesign):
+    '''Base class command handler for: eda lec ...'''
+
+    CHECK_REQUIRES = [Tool]
+    error_on_no_files_or_targets = False
+    error_on_missing_top = False # we'll override it.
+
+    command_name = 'lec'
+
+    def __init__(self, config: dict):
+        CommandDesign.__init__(self, config=config)
+        self.args.update({
+            'designs': [],
+            'synth': True,
+        })
+        self.args_help.update({
+            'designs': (
+                'Set the two LEC comparison designs: --designs=<target1> --designs=<target2>,'
+                ' use this arg twice'
+            ),
+            'synth': 'run synthesis on the two designs prior to running LEC',
+        })
+
+        self.synth_design_verilog_fpaths = ['', '']
+
+
+    def do_it(self) -> None:
+        '''Common do_it() method that child classes can use prior to customization'''
+
+        # set_tool_defines() is from class Tool. Since that is not inherited yet, but
+        # should be by any handlers, check on the existence of set_tool_defines, and
+        # error if not present.
+        if not all(isinstance(self, x) for x in self.CHECK_REQUIRES):
+            self.error('CommandLec.do_it() requires a Tool to be in parent classes, but none is.',
+                       f'{self.CHECK_REQUIRES=}')
+            return
+
+        # add defines for this job from Tool class if present
+        self.command_safe_set_tool_defines() # (Command.command_safe_set_tool_defines)
+
+        # dump our config to work-dir for debug
+        self.write_eda_config_and_args()
+
+        # Note - we do not support --export in LEC.
+        # Derived classes can do the rest, can call CommandLec.do_it(self) as a first step.
+
+
+    def process_tokens(self, tokens: list, process_all: bool = True,
+                       pwd: str = os.getcwd()) -> list:
+        unparsed = CommandDesign.process_tokens(
+            self, tokens=tokens, process_all=process_all, pwd=pwd
+        )
+
+        if self.status_any_error():
+            return unparsed
+
+        # add defines for this job type
+        if not self.args['top']:
+            self.args['top'] = 'eda.lec'
+
+        # we require there to be two --designs set.
+        if not self.args['designs'] and len(self.args['designs']) != 2:
+            self.error('Requires two designs via --designs=<target1> --designs=<target2>',
+                       f'designs={self.args["designs"]}')
+            return []
+
+        # Before we do anything else, make sure the two designs actually exist.
+        for design in self.args['designs']:
+            # maybe it's a file?
+            if os.path.isfile(design):
+                pass
+            elif design in eda_extract_targets.get_targets(partial_paths=[design], base_path=pwd):
+                pass
+            else:
+                self.error(f'--designs={design}, value is not a file or target')
+
+        # create our work dir
+        self.create_work_dir()
+        self.run_dep_commands()
+        self.do_it()
+        return unparsed
+
+
+    def get_synth_result_fpath(self, target: str) -> str:
+        '''Derived classes must define. Given a synth target for one of the two
+
+        designs to compare, return the location of the synthesis file'''
+        raise NotImplementedError

opencos/commands/shell.py

@@ -0,0 +1,202 @@
+'''opencos.commands.shell - Base class command handler for: eda shell ...
+
+Not intended to be overriden by Tool based classes.'''
+
+# Note - tricky to eliminate it with inheritance when calling reusable methods.
+# pylint: disable=R0801
+
+# TODO(drew): clean up CommandShell.check_logs_for_errors and CommandShell.run_commands_check_logs
+#   These also share a lot with CommandSim.* methods, so consider refactoring to share code,
+#   for example, CommandShell.do_export could move to CommandDesign, and derived classes
+#   set the allow-listed args to pass to export.
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+
+import os
+
+from opencos import util, export_helper
+from opencos.eda_base import CommandDesign
+
+
+class CommandShell(CommandDesign):
+    '''Base class command handler for: eda sim ...'''
+
+    command_name = 'shell'
+
+    def __init__(self, config: dict):
+        CommandDesign.__init__(self, config=config)
+        self.args.update({
+            'pass-pattern': "",
+            'log-bad-strings': [],
+            'log-must-strings': [],
+        })
+        self.args_help.update({
+            'log-bad-strings': (
+                'strings that if present in the log will cause an `eda shell` error'
+            ),
+            'log-must-strings': (
+                'strings that are required by the log to not-fail the `eda shell` call'
+            ),
+            'pass-pattern': (
+                'Additional string required to pass the `eda shell` call, appends to'
+                ' log-must-strings'
+            ),
+        })
+
+    def process_tokens(self, tokens: list, process_all: bool = True,
+                       pwd: str = os.getcwd()) -> list:
+        unparsed = CommandDesign.process_tokens(
+            self, tokens=tokens, process_all=process_all, pwd=pwd
+        )
+
+        if self.status_any_error():
+            return unparsed
+
+        if self.args['top']:
+            # create our work dir
+            self.create_work_dir()
+            self.run_dep_commands()
+            self.do_it()
+        return unparsed
+
+
+    def run_commands_check_logs( # pylint: disable=dangerous-default-value
+            self, commands: list , check_logs: bool = True, log_filename=None,
+            bad_strings: list = [],
+            must_strings: list = [],
+            use_bad_strings: bool = True, use_must_strings: bool = True
+    ) -> None:
+        '''Returns None, runs all commands (each element is a list) and checks logs
+
+        for bad-strings and must-strings (args or class member vars)
+        '''
+
+        for obj in commands:
+
+            assert isinstance(obj, list), \
+                (f'{self.target=} command {obj=} is not a list or util.ShellCommandList,'
+                 ' not going to run it.')
+
+            clist = list(obj).copy()
+            tee_fpath = getattr(obj, 'tee_fpath', None)
+
+            util.debug(f'run_commands_check_logs: {clist=}, {tee_fpath=}')
+
+            log_fname = None
+            if tee_fpath:
+                log_fname = tee_fpath
+            if log_filename:
+                log_fname = log_filename
+
+            self.exec(work_dir=self.args['work-dir'], command_list=clist, tee_fpath=tee_fpath)
+
+            if check_logs and log_fname:
+                self.check_logs_for_errors(
+                    filename=log_fname, bad_strings=bad_strings, must_strings=must_strings,
+                    use_bad_strings=use_bad_strings, use_must_strings=use_must_strings
+                )
+
+
+    def do_export(self) -> None:
+        '''CommandShell helper for handling args --export*
+
+        We allow commands such as: eda shell --export <target>
+        '''
+
+        out_dir = os.path.join(self.args['work-dir'], 'export')
+
+        target = self.target
+        if not target:
+            target = 'test'
+
+        export_obj = export_helper.ExportHelper(
+            cmd_design_obj=self,
+            eda_command=self.command_name,
+            out_dir=out_dir,
+            # Note this may not be the correct target for debug infomation,
+            # so we'll only have the first one.
+            target=target
+        )
+
+        # Set things in the exported: DEPS.yml
+        tool = self.args.get('tool', None)
+        # Certain args are allow-listed here
+        deps_file_args = []
+        for a in self.get_command_line_args():
+            if any(a.startswith(x) for x in [
+                    '--log-must',
+                    '--log-bad',
+                    '--pass-pattern']):
+                deps_file_args.append(a)
+
+        export_obj.run(
+            deps_file_args=deps_file_args,
+            export_json_eda_config={
+                'tool': tool,
+            }
+        )
+
+        if self.args['export-run']:
+
+            # remove the '--export' named args, we don't want those.
+            args_no_export = self.get_command_line_args(remove_args_startswith=['export'])
+
+            command_list = ['eda', self.command_name] + args_no_export + [target]
+
+            util.info(f'export-run: from {export_obj.out_dir=}: {command_list=}')
+            self.exec(
+                work_dir=export_obj.out_dir,
+                command_list=command_list,
+            )
+
+
+    def do_it(self) -> None:
+        self.write_eda_config_and_args()
+
+        if self.is_export_enabled():
+            # If we're exporting the target, we do NOT run the test here
+            # (do_export() may run the test in a separate process and
+            # from the out_dir if --export-run was set)
+            self.do_export()
+
+
+    def check_logs_for_errors( # pylint: disable=dangerous-default-value
+            self, filename: str,
+            bad_strings: list = [], must_strings: list = [],
+            use_bad_strings: bool = True, use_must_strings: bool = True
+    ) -> None:
+        '''Returns None, checks logs using args bad_strings, must_strings,
+
+        and internals self.args["log-[bad|must]-strings"] (lists).
+        '''
+
+        _bad_strings = bad_strings
+        _must_strings = must_strings
+        # append, if not they would 'replace' the args values:
+        if use_bad_strings:
+            _bad_strings = bad_strings + self.args.get('log-bad-strings', [])
+        if use_must_strings:
+            _must_strings = must_strings + self.args.get('log-must-strings', [])
+
+        if self.args['pass-pattern'] != "":
+            _must_strings.append(self.args['pass-pattern'])
+
+        if len(_bad_strings) > 0 or len(_must_strings) > 0:
+            hit_bad_string = False
+            hit_must_string_dict = dict.fromkeys(_must_strings)
+            fname = os.path.join(self.args['work-dir'], filename)
+            with open(fname, 'r', encoding='utf-8') as f:
+                for lineno, line in enumerate(f):
+                    if any(must_str in line for must_str in _must_strings):
+                        for k, _ in hit_must_string_dict.items():
+                            if k in line:
+                                hit_must_string_dict[k] = True
+                    if any(bad_str in line for bad_str in _bad_strings):
+                        hit_bad_string = True
+                        self.error(f"log {fname}:{lineno} contains one of {_bad_strings=}")
+
+            if hit_bad_string:
+                self.status += 1
+            if any(x is None for x in hit_must_string_dict.values()):
+                self.error(f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
+                           f" {hit_must_string_dict=}")
+                self.status += 1

opencos/commands/sim.py

@@ -306,7 +306,7 @@ class CommandSim(CommandDesign):
             if hit_bad_string:
                 self.status += 1
             if any(x is None for x in hit_must_string_dict.values()):
-                self.error(f"Didn't get all passing patternsin log {fname}: {_must_strings=}",
+                self.error(f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
                            f" {hit_must_string_dict=}")
                 self.status += 1
 

opencos/deps_helpers.py

@@ -57,6 +57,8 @@ class Defaults:
         'with-tools',
         'with-args',
         'args',
+        'deps',
+        'reqs',
         'defines',
         'incdirs',
         'replace-config-tools',

opencos/eda.py

@@ -87,6 +87,8 @@ Where <command> is one of:
     upload       - Uploads a finished design into hardware
     open         - Opens a project
     export       - Export files related to a target, tool independent
+    shell        - Runs only commands for DEPS target (like sim or elab, but stops prior to tool)
+    targets      - list all possible targets given glob path.
     help         - This help (without args), or i.e. "eda help sim" for specific help
 
 And <files|targets, ...> is one or more source file or DEPS markup file target,
@@ -320,9 +322,10 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     for value in unparsed:
         if value in config['DEFAULT_HANDLERS'].keys():
             command = value
-            if value in config['command_uses_no_tools']:
+            if not parsed.tool and value in config['command_tool_is_optional']:
+                # only do this if --tool was not set.
                 run_auto_tool_setup = False
-            unparsed.remove(value)
+            unparsed.remove(value) # remove command (flist, export, targets, etc)
             break
 
     if not interactive:
@@ -361,7 +364,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     util.debug(f'{type(sco)=}')
     if not parsed.tool and \
        command not in config.get('command_determines_tool', []) and \
-       command not in config.get('command_uses_no_tools', []):
+       command not in config.get('command_tool_is_optional', []):
         use_tool = which_tool(command, config)
         util.info(f"--tool not specified, using default for {command=}: {use_tool}")
 

opencos/eda_base.py

@@ -302,6 +302,8 @@ class Command:
 
     def exec(self, work_dir, command_list, background=False, stop_on_error=True,
              quiet=False, tee_fpath=None, shell=False):
+        if not tee_fpath and getattr(command_list, 'tee_fpath', None):
+            tee_fpath = getattr(command_list, 'tee_fpath', '')
         if not quiet:
             util.info(f"exec: {' '.join(command_list)} (in {work_dir}, {tee_fpath=})")
         original_cwd = util.getcwd()
@@ -686,6 +688,7 @@ class CommandDesign(Command):
         self.files_sv = []
         self.files_vhd = []
         self.files_cpp = []
+        self.files_sdc = []
         self.files_non_source = []
         self.files_caller_info = {}
         self.dep_shell_commands = [] # each list entry is a {}
@@ -739,9 +742,9 @@ class CommandDesign(Command):
             util.info(f'run_dep_shell_commands {iter=}: {d=}')
             clist = util.ShellCommandList(d['exec_list'])
             # NOTE(drew): shell=True subprocess call, can disable with self.config
-            #  However, in Windows, we seem to have to run these with shell=False
             if sys.platform.startswith('win'):
-                self.exec(self.args['work-dir'], clist, shell=False)
+                # for Windows, we run shell=True otherwise most built-in cmd.exe calls won't work.
+                self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath, shell=True)
             else:
                 self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
                           shell=self.config.get('deps_subprocess_shell', False))
@@ -760,7 +763,8 @@ class CommandDesign(Command):
                 self.files.pop(key)
                 self.files[new_key] = True
 
-        my_file_lists_list = [self.files_v, self.files_sv, self.files_vhd, self.files_cpp]
+        my_file_lists_list = [self.files_v, self.files_sv, self.files_vhd, self.files_cpp,
+                              self.files_sdc]
         for my_file_list in my_file_lists_list:
             for iter,value in enumerate(my_file_list):
                 if value and type(value) is str and value.startswith(self._work_dir_add_srcs_path_string):
@@ -1029,6 +1033,7 @@ class CommandDesign(Command):
         sv_file_ext_list = known_file_ext_dict.get('systemverilog', [])
         vhdl_file_ext_list = known_file_ext_dict.get('vhdl', [])
         cpp_file_ext_list = known_file_ext_dict.get('cpp', [])
+        sdc_file_ext_list = known_file_ext_dict.get('synth_constraints', [])
 
         if forced_extension:
             # If forced_extension='systemverilog', then use the first known extension for
@@ -1057,6 +1062,9 @@ class CommandDesign(Command):
         elif file_ext in cpp_file_ext_list:
             self.files_cpp.append(file_abspath)
             util.debug("Added C++ file %s as %s" % (filename, file_abspath))
+        elif file_ext in sdc_file_ext_list:
+            self.files_sdc.append(file_abspath)
+            util.debug("Added SDC file %s as %s" % (filename, 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 path)
@@ -1154,7 +1162,7 @@ class CommandDesign(Command):
             else:
                 target_name = os.path.join(".", token) # prepend ./so that we always have a <path>/<file>
 
-            util.debug(f'Calling self.resolve_target on {target_name=}')
+            util.debug(f'Calling self.resolve_target on {target_name=} ({token=})')
             if self.resolve_target(target_name, caller_info=caller_info):
                 if not self.args['top']:
                     # last cmd line arg was a target that we'll likely use for inferred top.

opencos/eda_config.py

@@ -30,7 +30,7 @@ class Defaults:
         'vars',
         'file_extensions',
         'command_determines_tool',
-        'command_uses_no_tools',
+        'command_tool_is_optional',
         'tools',
         'auto_tools_order',
     ])

opencos/eda_config_defaults.yml

@@ -9,19 +9,21 @@ DEFAULT_HANDLERS:
   sim         : opencos.commands.CommandSim
   elab        : opencos.commands.CommandElab
   synth       : opencos.commands.CommandSynth
-  flist       : opencos.commands.CommandFList
   proj        : opencos.commands.CommandProj
   build       : opencos.commands.CommandBuild
   upload      : opencos.commands.CommandUpload
   open        : opencos.commands.CommandOpen
+  lec         : opencos.commands.CommandLec
   # These commands don't necessarily require a tool
   multi       : opencos.commands.CommandMulti
   tools-multi : opencos.commands.CommandToolsMulti
   sweep       : opencos.commands.CommandSweep
+  flist       : opencos.commands.CommandFList
   # These commands (waves, export, targets) do not require a tool, or
   # will self determine the tool:
   waves       : opencos.commands.CommandWaves
   export      : opencos.commands.CommandExport
+  shell       : opencos.commands.CommandShell
   targets     : opencos.commands.CommandTargets
 
 
@@ -60,6 +62,9 @@ file_extensions:
     - .vhdl
   cpp:
     - .cpp
+  synth_constraints:
+    - .sdc
+    - .xdc
 
   inferred_top:
     # file extensions that we can infer "top" module from, if --top omitted.
@@ -72,8 +77,9 @@ command_determines_tool:
   # eda commands that will self-determine the tool to use
   - waves
 
-command_uses_no_tools:
-  # eda commands that do not use a tool at all, will skip auto_tools_order
+command_tool_is_optional:
+  # eda commands that may not need to use a tool at all, will skip auto_tools_order if --tool=None (default)
+  - flist
   - export
   - targets
 
@@ -333,6 +339,15 @@ auto_tools_order:
         flist:  opencos.tools.vivado.CommandFListVivado
         build:  opencos.tools.vivado.CommandBuildVivado
 
+    slang_yosys:
+      exe: yosys
+      requires_cmd:
+        - yosys -m slang
+      handlers:
+        elab:  opencos.tools.slang_yosys.CommandElabSlangYosys
+        synth: opencos.tools.slang_yosys.CommandSynthSlangYosys
+        lec:   opencos.tools.slang_yosys.CommandLecSlangYosys
+
     tabbycad_yosys:
       exe: yosys
       requires_env:
@@ -350,13 +365,13 @@ auto_tools_order:
         elab:  opencos.tools.invio_yosys.CommandElabInvioYosys
         synth: opencos.tools.invio_yosys.CommandSynthInvioYosys
 
-    slang_yosys:
+    yosys:
       exe: yosys
       requires_cmd:
-        - yosys -m slang
+        - yosys
       handlers:
-        elab:  opencos.tools.slang_yosys.CommandElabSlangYosys
-        synth: opencos.tools.slang_yosys.CommandSynthSlangYosys
+        synth: opencos.tools.slang_yosys.CommonSynthYosys
+        lec:   opencos.tools.slang_yosys.CommandLecYosys
 
     questa:
       exe: qrun

opencos/eda_extract_targets.py

@@ -86,8 +86,9 @@ def get_path_and_pattern(partial_path: str = '', base_path=str(Path('.'))) -> (s
 
 
 
-def run(partial_paths: list, base_path=str(Path('.'))) -> None:
-    '''Returns None, prints DEPS keys into pretty columns, using arg
+
+def get_targets(partial_paths: list, base_path=str(Path('.'))) -> list:
+    '''Returns a list of DEPS keys into pretty columns, using arg
 
     partial_path as a string filter for target completions.
     '''
@@ -113,7 +114,16 @@ def run(partial_paths: list, base_path=str(Path('.'))) -> None:
         for key in keys:
             targets_set.add(key)
 
-    data = list(targets_set)
+    return list(targets_set)
+
+
+def run(partial_paths: list, base_path=str(Path('.'))) -> None:
+    '''Returns None, prints DEPS keys into pretty columns, using arg
+
+    partial_path as a string filter for target completions.
+    '''
+
+    data = get_targets(partial_paths=partial_paths, base_path=base_path)
     data.sort()
     print_columns_manual(data=data, num_columns=4, auto_columns=True)
 

opencos/export_helper.py

@@ -352,23 +352,25 @@ class ExportHelper:
             }
         }
 
-        if len(deps_file_args) > 0:
+
+        if deps_file_args:
             data[self.target]['args'] = deps_file_args.copy()
 
         if self.args.get('top', None):
             data[self.target]['top'] = self.args['top']
 
-        if len(self.cmd_design_obj.defines.keys()) > 0:
+        if self.cmd_design_obj.defines:
             data[self.target]['defines'] = self.cmd_design_obj.defines.copy()
             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)
 
-        if len(self.cmd_design_obj.files_non_source) > 0:
+        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()
-            for fullpath in self.cmd_design_obj.files_non_source:
+            for fullpath in reqs_fullpath_list:
                 filename = os.path.split(fullpath)[1]
                 data[self.target]['reqs'].append(filename)
 

opencos/files.py

@@ -23,6 +23,7 @@ FORCE_PREFIX_DICT = {
     'v@': 'verilog',
     'vhdl@': 'vhdl',
     'cpp@': 'cpp',
+    'sdc@': 'synth_constraints',
 }
 
 ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))

opencos/tests/helpers.py

@@ -5,6 +5,7 @@
 import json
 import os
 import shutil
+from pathlib import Path
 
 from contextlib import redirect_stdout, redirect_stderr
 
@@ -26,7 +27,7 @@ def can_run_eda_command(*commands, config: dict) -> bool:
 
 def chdir_remove_work_dir(startpath, relpath):
     '''Changes dir to startpath/relpath, removes the work directories (eda.work, eda.export*)'''
-    os.chdir(os.path.join(startpath, relpath))
+    os.chdir(os.path.join(str(Path(startpath)), str(Path(relpath))))
     for outdir in ['eda.export', 'eda.work']:
         fullp = os.path.join(os.getcwd(), outdir)
         if fullp and ('eda.' in fullp) and os.path.isdir(fullp):
@@ -128,7 +129,7 @@ class Helpers:
         '''Changes directory to self.DEFAULT_DIR and removes eda.work, eda.export paths'''
         chdir_remove_work_dir('', self.DEFAULT_DIR)
 
-    def log_it(self, command_str:str, logfile=None, use_eda_wrap=True):
+    def log_it(self, command_str:str, logfile=None, use_eda_wrap=True) -> int:
         '''Replacement for calling eda.main or eda_wrap, when you want an internal logfile
 
         Usage:

opencos/tests/test_deps_schema.py

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