opencos-eda 0.2.31__tar.gz → 0.2.33__tar.gz

{opencos_eda-0.2.31/opencos_eda.egg-info → opencos_eda-0.2.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.31
+Version: 0.2.33
 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

{opencos_eda-0.2.31 → opencos_eda-0.2.33}/opencos/commands/multi.py

@@ -268,26 +268,23 @@ class CommandMulti(CommandParallel):
         if parsed.parallel < 1 or parsed.parallel > 256:
             self.error("Arg 'parallel' must be between 1 and 256")
 
-        for value in unparsed:
-            if value in self.config['command_handler'].keys():
-                command = value
-                unparsed.remove(value)
-                break
+        command = self.get_command_from_unparsed_args(tokens=unparsed)
 
         # Need to know the tool for this command, either it was set correctly via --tool and/or
         # the command (class) will tell us.
         all_multi_tools = self.multi_which_tools(command)
 
+        single_cmd_unparsed = self.get_unparsed_args_on_single_command(
+            command=command, tokens=unparsed
+        )
+
         util.debug(f"Multi: {unparsed=}, looking for target_globs")
         for token in unparsed:
-            if token.startswith("-") or token.startswith("+"):
-                # save all --arg, -arg, or +plusarg for the job target:
-                arg_tokens.append(token)
-            else:
+            if token in single_cmd_unparsed:
                 target_globs.append(token)
+            else:
+                arg_tokens.append(token)
 
-        if command == "":
-            self.error("Didn't get a command after 'multi'!")
 
         # now we need to expand the target list
         self.single_command = command
@@ -379,27 +376,23 @@ class CommandMulti(CommandParallel):
         # Do not use for CommandMulti, b/c we support list of tools.
         raise NotImplementedError
 
-    def multi_which_tools(self, command):
+    def multi_which_tools(self, command) -> list:
         '''returns a list, or None, of the tool that was already determined to run the command
 
         CommandToolsMulti will override and return its own list'''
         return [eda_base.which_tool(command, config=self.config)]
 
-    def _append_job_command_args(self, command_list: list) -> None:
-        # Many args were consumed by eda before CommandMulti saw them
-        # --config-yml, --tool, --eda-safe. Some are in self.config.
-        # We need to apply those eda level args to each multi exec-command
-        # TODO(drew): this is really clunky. It would be way eaiser if our
-        # self.config['eda_original_args'] had a better way of passing allow-listed
-        # args from multi --> exec-command.
-        # Alternatively, we could track all the parsed args up to this point, that have
-        # deviated from the default value(s), and apply those as needed.
-        if any(a.startswith('--config-yml') for a in self.config['eda_original_args']):
-            cfg_yml_fname = self.config.get('config-yml', None)
-            if cfg_yml_fname:
-                command_list.append(f'--config-yml={cfg_yml_fname}')
-        if '--eda-safe' in self.config['eda_original_args']:
-            command_list.append('--eda-safe')
+    def _append_job_command_args( # pylint: disable=R0913,R0917 # too-many-arguments
+            self, command_list: list, tool: str, all_multi_tools: list, short_target: str,
+            command: str
+    ) -> None:
+
+        super().update_args_list(args=command_list, tool=tool)
+        if self.args.get('export-jsonl', False):
+            # Special case for 'multi' --export-jsonl, run reach child with --export-json
+            command_list.append('--export-json')
+        if tool and len(all_multi_tools) > 1:
+            command_list.append(f'--sub-work-dir={short_target}.{command}.{tool}')
 
     def append_jobs_from_targets(self, args:list):
         '''Helper method in CommandMulti to apply 'args' (list) to all self.targets,
@@ -422,17 +415,11 @@ class CommandMulti(CommandParallel):
 
             _, short_target = os.path.split(target) # trim path info on left
 
-            self._append_job_command_args(command_list=command_list)
+            self._append_job_command_args(
+                command_list=command_list, tool=tool, all_multi_tools=all_multi_tools,
+                short_target=short_target, command=command
+            )
 
-            if tool:
-                # tool can be None, we won't add it to the command (assumes default from config-yml)
-                command_list.append('--tool=' + tool)
-                if len(all_multi_tools) > 1:
-                    command_list += [f'--sub-work-dir={short_target}.{command}.{tool}']
-
-            if self.args.get('export-jsonl', False):
-                # Special case for 'multi' --export-jsonl, run reach child with --export-json
-                command_list += [ '--export-json']
             # if self.args['parallel']: command_list += ['--quiet']
             command_list += args # put the args prior to the target.
             command_list += [target]
@@ -540,6 +527,8 @@ class CommandMulti(CommandParallel):
                                                     output_json_path=output_json_path)
 
 
+
+
 class CommandToolsMulti(CommandMulti):
     '''eda.py command handler for: eda tools-multi <args,targets,target-globs,...>
 

opencos_eda-0.2.33/opencos/commands/sweep.py

@@ -0,0 +1,230 @@
+'''opencos.commands.sweep - command handler for: eda sweep ...
+
+These are not intended to be overriden by child classes. They do not inherit Tool classes.
+'''
+
+import os
+import re
+
+from opencos import util
+from opencos.eda_base import CommandDesign, CommandParallel, get_eda_exec, which_tool
+
+class CommandSweep(CommandDesign, CommandParallel):
+    '''Command handler for: eda sweep ...'''
+
+    command_name = 'sweep'
+
+    def __init__(self, config:dict):
+        CommandDesign.__init__(self, config=config)
+        CommandParallel.__init__(self, config=config)
+        self.sweep_target = ''
+        self.single_command = ''
+        self.args.update({
+            'sweep': []
+        })
+        self.args_help.update({
+            "sweep": ("List append arg, where range or value expansion is peformed on the RHS:"
+                      " --sweep='--arg0=(start,last,iter=1)' "
+                      " --sweep='--arg1=[val0,val1,val2,...]' "
+                      " --sweep='+define+NAME0=(start,last,iter=1)' "
+                      " --sweep='+define+NAME1=[val0,val1,val2,...]' "
+                      " --sweep='+define+[NAME0,NAME1,NAME2,...]' ."
+                      " Note that range expansion of (1,4) will expand to values [1,2,3,4]."
+                      ),
+        })
+
+
+    def check_args(self) -> None:
+        '''Returns None, checks self.args (use after args parsed)'''
+        if self.args['parallel'] < 1 or self.args['parallel'] > 256:
+            self.error(f"Arg {self.args['parallel']=} must be between 1 and 256")
+
+    def _append_sweep_args(self, arg_tokens: list) -> None:
+        '''Modifies list arg_tokens, using known top-level args'''
+        tool = which_tool(command=self.single_command, config=self.config)
+        super().update_args_list(args=arg_tokens, tool=tool)
+
+
+    def process_tokens(
+            self, tokens: list, process_all: bool = True,
+            pwd: str = os.getcwd()
+    ) -> list:
+        '''CommandSweep.process_tokens(..) is likely the entry point for: eda sweep <command> ...
+
+        - handles remaining CLI arguments (tokens list)
+        - builds sweep_axis_list to run multiple jobs for the target
+        '''
+
+        # 'sweep' is special in the way it handles tokens, due to most of them being processed by
+        # a sub instance
+        sweep_axis_list = []
+        arg_tokens = []
+
+        _, unparsed = self.run_argparser_on_list(
+            tokens=tokens,
+            parser_arg_list=[
+                'parallel',
+                'sweep',
+            ],
+            apply_parsed_args=True
+        )
+
+        self.check_args()
+
+        self.single_command = self.get_command_from_unparsed_args(tokens=unparsed)
+
+        self._append_sweep_args(arg_tokens=arg_tokens)
+
+        for sweep_arg_value in self.args['sweep']:
+            # Deal with --sweep= args we already parsed, but haven't expanded yet.
+            sweep_arg_value = util.strip_outer_quotes(sweep_arg_value)
+            sweep_axis_list_entry = self._process_sweep_arg(sweep_arg_value=sweep_arg_value)
+            if sweep_axis_list_entry:
+                sweep_axis_list.append(sweep_axis_list_entry)
+
+
+        # command, --parallel, and --sweep already processed by argparse,
+        # let's tentatively parse what the child jobs cannot consume.
+        # Whatever is leftover is either an eda target, or another unparsed token.
+        single_cmd_unparsed = self.get_unparsed_args_on_single_command(
+            command=self.single_command, tokens=unparsed
+        )
+
+        for token in unparsed:
+            if token in single_cmd_unparsed:
+
+                if self.resolve_target(token, no_recursion=True):
+                    if self.sweep_target:
+                        self.error("Sweep can only take one target, already got",
+                                   f"{self.sweep_target} now getting {token}")
+                    self.sweep_target = token
+                else:
+                    # If we don't know what to do with it, pass it to downstream
+                    arg_tokens.append(token)
+
+            else:
+                # If it wasn't in single_cmd_unparsed, then it can definitely be
+                # consumed downstream
+                arg_tokens.append(token)
+
+
+        # now we need to expand the target list
+        util.debug(f"Sweep: command:    '{self.single_command}'")
+        util.debug(f"Sweep: arg_tokens: '{arg_tokens}'")
+        util.debug(f"Sweep: target:     '{self.sweep_target}'")
+
+        # now create the list of jobs, support one axis
+        self.jobs = []
+
+        self.expand_sweep_axis(arg_tokens=arg_tokens, sweep_axis_list=sweep_axis_list)
+        self.run_jobs(command=self.single_command)
+        return [] # we used all of unparsed.
+
+
+    @staticmethod
+    def _process_sweep_arg(sweep_arg_value: str) -> dict:
+        '''If processed, returns a non-empty dict. Handles processing of --sweep=VALUE
+
+        Where VALUE could be one of:
+           --arg0=(1,4)
+           --arg1=[val0,val1]
+           +define+NAME0=[val0,val1]
+
+        Return value is {} or {'lhs': str, 'operator': str (+ or =), 'values': list}
+        '''
+
+        sweep_arg_value = util.strip_outer_quotes(sweep_arg_value)
+
+        util.debug(f'{sweep_arg_value=}')
+        # Try to match a sweep range expansion:
+        #   --sweep='--arg0=(1,4)'
+        #   --sweep='--arg0=(1,4,1)'
+        #   --sweep='+define+NAME0=(1,4,1)'
+        m = re.match(
+            r'(.*)(\=) \(  ([\d\.]+)  \,  ([\d\.]+)  (\, ([\d\.]+) )?  \)'.replace(' ',''),
+            sweep_arg_value
+        )
+        if m:
+            lhs = m.group(1)
+            operator = m.group(2)
+            sweep_axis_values = []
+            if m.group(5):
+                rhs_range_iter = int(m.group(6))
+            else:
+                rhs_range_iter = 1
+            for v in range(int(m.group(3)), int(m.group(4)) + 1, rhs_range_iter):
+                sweep_axis_values.append(v)
+            util.debug(f"Sweep axis: {lhs} {operator} {sweep_axis_values}")
+            return {
+                'lhs': lhs,
+                'operator': operator,
+                'values': sweep_axis_values,
+            }
+
+        # Try to match a sweep list value expansion:
+        #   --sweep='--arg0=[1,2]'
+        #   --sweep='--arg1=[3,4,5,6]'
+        #   --sweep='+define+NAME=[8,9]'
+        #   --sweep='+define+[NAME0,NAME1,NAME2]'
+        #   --sweep='+define+[NAME0=1,NAME1=22,NAME2=46]'
+        m = re.match(
+            r'(.*)([\=\+]) \[  ([^\]]+) \] '.replace(' ',''),
+            sweep_arg_value
+        )
+        if m:
+            sweep_axis_values = []
+            lhs = m.group(1)
+            operator = m.group(2)
+            for v in m.group(3).split(','):
+                sweep_axis_values.append(v)
+            util.debug(f"Sweep axis: {lhs} {operator} {sweep_axis_values}")
+            return {
+                'lhs': lhs,
+                'operator': operator,
+                'values': sweep_axis_values,
+            }
+
+        util.warning(f'Ignored unprocessed expansion for --sweep={sweep_arg_value}')
+        return {}
+
+
+    def expand_sweep_axis(
+            self, arg_tokens: list, sweep_axis_list: list, sweep_string: str = ""
+    ) -> None:
+        '''Returns None, appends jobs to self.jobs to be run by CommandParallel.run_jobs(..)'''
+
+        util.debug(f"Entering expand_sweep_axis: command={self.single_command},",
+                   f"target={self.sweep_target}, arg_tokens={arg_tokens},",
+                   f"sweep_axis_list={sweep_axis_list}")
+        if not sweep_axis_list:
+            # we aren't sweeping anything, create one job
+            snapshot_name = self.sweep_target.replace('../','').replace('/','_') + sweep_string
+            eda_path = get_eda_exec('sweep')
+            self.jobs.append({
+                'name' : snapshot_name,
+                'index' : len(self.jobs),
+                'command_list' : (
+                    [eda_path, self.single_command, self.sweep_target,
+                     '--job_name', snapshot_name] + arg_tokens
+                )
+            })
+            return
+
+        sweep_axis = sweep_axis_list.pop(0)
+        lhs = sweep_axis['lhs']
+        operator = sweep_axis['operator']
+
+        lhs_trimmed = lhs.replace('-', '').replace('+', '').replace('=', '')
+
+        for v in sweep_axis['values']:
+            this_arg_tokens = arg_tokens.copy()
+            this_arg_tokens.append(f'{lhs}{operator}{v}')
+
+            v_string = f"{v}".replace('.','p')
+            this_sweep_string = sweep_string + f"_{lhs_trimmed}_{v_string}"
+
+            self.expand_sweep_axis(
+                arg_tokens=this_arg_tokens,
+                sweep_axis_list=sweep_axis_list,
+                sweep_string=this_sweep_string
+            )

{opencos_eda-0.2.31 → opencos_eda-0.2.33}/opencos/deps_helpers.py

@@ -1,6 +1,7 @@
 
 import fnmatch
 import os
+from pathlib import Path
 import sys
 import re
 import shutil
@@ -1149,9 +1150,9 @@ def parse_deps_peakrdl(line : str, target_path : str, target_node : str, enable
 
 
     shell_commands = [
-        [ 'peakrdl', 'regblock', '-o', 'peakrdl/'] + args_list,
+        [ 'peakrdl', 'regblock', '-o', str(Path('peakrdl/'))] + args_list,
         # Edit file to apply some verilator waivers, etc, from peakrdl_cleanup.py:
-        [ 'python3', peakrdl_cleanup_py, f'peakrdl/{top}.sv', f'peakrdl/{top}.sv' ],
+        [ 'python3', peakrdl_cleanup_py, str(Path(f'peakrdl/{top}.sv')), str(Path(f'peakrdl/{top}.sv')) ],
     ]
 
     ret_dict = {

{opencos_eda-0.2.31 → opencos_eda-0.2.33}/opencos/deps_schema.py

@@ -125,7 +125,7 @@ import sys
 
 from schema import Schema, Or, Optional, SchemaError
 
-from opencos.deps_helpers import deps_markup_safe_load, get_deps_markup_file
+from opencos import util, deps_helpers
 
 # 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,
@@ -299,8 +299,10 @@ FILE_SIMPLIFIED = Schema(
 
 
 
-def check(data: dict, schema_obj=FILE):
+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
@@ -310,6 +312,37 @@ def check(data: dict, schema_obj=FILE):
         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)
+    if util.args['errors'] > current_errors:
+        return False, data
+    return True, data
+
+
+def check_file(filepath: str, schema_obj=FILE) -> (bool, str, str):
+    '''Returns tuple (bool pass/fail, str error retdata, str deps_filepath)'''
+
+    deps_filepath = filepath
+    if os.path.isdir(filepath):
+        deps_filepath = deps_helpers.get_deps_markup_file(base_path=filepath)
+
+    # get deps file
+    if not os.path.exists(deps_filepath):
+        print(f'ERROR: internal error(s) no DEPS.[yml|..] found in {filepath=}')
+        return False, '', deps_filepath
+
+    passes, data = deps_markup_safe_load(deps_filepath)
+    if not passes:
+        print(f'ERROR: internal error(s) from deps_markup_safe_load({deps_filepath=})')
+        return False, '', deps_filepath
+
+    passes, retdata = check(data, schema_obj)
+    return passes, retdata, deps_filepath
+
+
+
 def check_files(files, schema_obj=FILE) -> bool:
     '''Returns True if files lint cleanly in the FILE schema.'''
 
@@ -319,20 +352,16 @@ def check_files(files, schema_obj=FILE) -> bool:
     passes_list = []
     error_files = []
     for filepath in files:
-        deps_filepath = filepath
-        if os.path.isdir(filepath):
-            # get deps file
-            deps_filepath = get_deps_markup_file(base_path=filepath)
-        assert os.path.exists(deps_filepath)
-        data = deps_markup_safe_load(deps_filepath)
-        passes, retdata = check(data, schema_obj)
+
+        passes, retdata, deps_filepath = check_file(filepath, schema_obj)
         passes_list.append(passes)
         if passes:
             print(f'{deps_filepath}: [PASS]')
         if not passes:
             print(f'ERROR: {deps_filepath}:')
-            print('-- retdata --')
-            print(retdata)
+            if retdata:
+                print('-- retdata --')
+                print(retdata)
             print(f'    previous error on: {deps_filepath}\n')
             error_files.append(deps_filepath)
 

{opencos_eda-0.2.31 → opencos_eda-0.2.33}/opencos/eda_base.py

@@ -398,12 +398,6 @@ class Command:
             else:
                 assert False, f'{key=} {value=} how do we do argparse for this type of value?'
 
-        # TODO(drew): it might be nice to support positional args here as a list
-        # self.target_args (files/targets/patterns), something like:
-        #    parser.add_argument(
-        #        'targets', nargs='+', help='positional arg for targets/files/pattern'
-        #    )
-
         return parser
 
 
@@ -425,7 +419,7 @@ class Command:
             parsed, unparsed = parser.parse_known_args(tokens + [''])
             unparsed = list(filter(None, unparsed))
         except argparse.ArgumentError:
-            self.error(f'problem attempting to parse_known_args for {tokens=}')
+            self.error(f'problem {command_name=} attempting to parse_known_args for {tokens=}')
 
         parsed_as_dict = vars(parsed)
 
@@ -506,7 +500,8 @@ class Command:
                 break
 
         if not ret and error_if_no_command:
-            self.error(f"Looking for a valid eda <command> but didn't find one in {tokens=}")
+            self.error(f"Looking for a valid eda {self.command_name} <command>",
+                       f"but didn't find one in {tokens=}")
         return ret
 
 
@@ -696,8 +691,12 @@ 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
-            self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
-                      shell=self.config.get('deps_subprocess_shell', False))
+            #  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)
+            else:
+                self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
+                          shell=self.config.get('deps_subprocess_shell', False))
 
     def update_file_lists_for_work_dir(self):
         if len(self.dep_work_dir_add_srcs) == 0:
@@ -748,7 +747,7 @@ class CommandDesign(Command):
         to unprocessed-plusargs.
         '''
 
-        # Since this may be coming from a raw CLI/bash argparser, we may have
+        # Since this may be coming from a raw CLI/bash/powershell argparser, we may have
         # args that come from shlex.quote(token), such as:
         #   token = '\'+define+OC_ROOT="/foo/bar/opencos"\''
         # So we strip all outer ' or " on the plusarg:
@@ -1514,3 +1513,57 @@ class CommandParallel(Command):
         if self.status == 0:
             self.status = 0 if len(self.jobs_status) == 0 else max(self.jobs_status)
         util.fancy_stop()
+
+
+    def update_args_list(self, args: list, tool: str) -> None:
+        '''Modfies list args, using allow-listed known top-level args:
+
+        --config-yml
+        --eda-safe
+        --tool
+
+        Many args were consumed by eda before CommandParallel saw them
+        (for commands like 'multi' or 'sweep'). Some are in self.config.
+         We need to apply those eda level args to each single exec-command
+        '''
+        if any(a.startswith('--config-yml') for a in self.config['eda_original_args']):
+            cfg_yml_fname = self.config.get('config-yml', None)
+            if cfg_yml_fname:
+                args.append(f'--config-yml={cfg_yml_fname}')
+        if '--eda-safe' in self.config['eda_original_args']:
+            args.append('--eda-safe')
+        if tool:
+            # tool can be None, if so we won't add it to the command (assumes default from
+            # config-yml auto load order)
+            args.append('--tool=' + tool)
+
+
+    def get_unparsed_args_on_single_command(self, command: str, tokens: list) -> list:
+        '''Returns a list of args that the single (non-multi) command cannot parse
+
+        This will error on bad --args or -arg, such as:
+          eda multi sim --seeeed=1
+        is not a valid arg in CommandSim
+
+        +arg=value, +arg+value will not be included in the return list, those are
+        intended to be consumed by the single/job command downstream (anything starting
+        with '+')
+
+        Used by CommandMulti and CommandSweep.
+        '''
+        single_cmd_handler = self.config['command_handler'][command](config=self.config)
+        single_cmd_parsed, single_cmd_unparsed = single_cmd_handler.run_argparser_on_list(
+            tokens=tokens.copy(),
+            apply_parsed_args=False,
+        )
+        util.debug(f'{self.command_name}: {single_cmd_unparsed=}')
+
+        # There should not be any single_cmd_unparsed args starting with '-'
+        bad_remaining_args = [x for x in single_cmd_unparsed if x.startswith('-')]
+        if bad_remaining_args:
+            self.error(f'for {self.command_name} {command=} the following args are unknown',
+                       f'{bad_remaining_args}')
+
+        # Remove unparsed args starting with '+', since those are commonly sent downstream to
+        # single job (example, CommandSim plusargs).
+        return [x for x in single_cmd_unparsed if not x.startswith('+')]

{opencos_eda-0.2.31 → opencos_eda-0.2.33}/opencos/peakrdl_cleanup.py

@@ -2,7 +2,6 @@
 
 import sys
 import os
-import subprocess
 
 def run(file_in, file_out):
     with open(file_in) as f:

{opencos_eda-0.2.31 → opencos_eda-0.2.33}/opencos/tests/helpers.py

@@ -11,6 +11,19 @@ from contextlib import redirect_stdout, redirect_stderr
 from opencos import eda, util
 from opencos import deps_schema
 
+def can_run_eda_command(*commands, config: dict) -> bool:
+    '''Returns True if we have any installed tool that can run: eda <command>'''
+    runnable = []
+    for command in list(commands):
+        handler = config['command_handler'].get(command, None)
+        if not handler:
+            return False
+        if handler and getattr(handler, 'CHECK_REQUIRES', []):
+            if not all(isinstance(handler, x) for x in getattr(handler, 'CHECK_REQUIRES', [])):
+                return False
+        runnable.append(True)
+    return runnable and all(runnable)
+
 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))
@@ -139,41 +152,52 @@ class Helpers:
             print(f'Wrote: {os.path.abspath(logfile)=}')
         return rc
 
-    def is_in_log(self, *want_str, logfile=None):
+    def is_in_log(self, *want_str, logfile=None, windows_path_support=False):
         '''Check if any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         if logfile is None:
             logfile = self.DEFAULT_LOG
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line or \
+                   (windows_path_support and want_str1 in line):
                     return True
         return False
 
-    def get_log_lines_with(self, *want_str, logfile=None):
+    def get_log_lines_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         if logfile is None:
             logfile = self.DEFAULT_LOG
         ret_list = []
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line:
+                    ret_list.append(line)
+                elif windows_path_support and want_str1 in line:
                     ret_list.append(line)
         return ret_list
 
-    def get_log_words_with(self, *want_str, logfile=None):
+    def get_log_words_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of *want_str within a single word
         in the logfile or self.DEFAULT_LOG
         '''
         if logfile is None:
             logfile = self.DEFAULT_LOG
         ret_list = []
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line:
                     for word in line.split():
-                        if want_str in word:
+                        if want_str0 in word:
                             ret_list.append(word)
+                elif windows_path_support and want_str1 in line:
+                    for word in line.split():
+                        if want_str1 in word:
+                            ret_list.append(word)
+
         return ret_list