def parse_module(self, program_text: str, incremental: int = 0) -> List[Tuple[str, str, str]]:
"""Return the module and program names for a test case.
Normally, the unit tests will parse the default ('__main__')
module and follow all the imports listed there. You can override
this behavior and instruct the tests to check multiple modules
by using a comment like this in the test case input:
# cmd: mypy -m foo.bar foo.baz
Return a list of tuples (module name, file name, program text).
"""
m = re.search('# cmd: mypy -m ([a-zA-Z0-9_. ]+)$', program_text, flags=re.MULTILINE)
m2 = re.search('# cmd2: mypy -m ([a-zA-Z0-9_. ]+)$', program_text, flags=re.MULTILINE)
if m2 is not None and incremental == 2:
# Optionally return a different command if in the second
# stage of incremental mode, otherwise default to reusing
# the original cmd.
m = m2
if m:
# The test case wants to use a non-default main
# module. Look up the module and give it as the thing to
# analyze.
module_names = m.group(1)
out = []
for module_name in module_names.split(' '):
path = build.find_module(module_name, [test_temp_dir])
with open(path) as f:
program_text = f.read()
out.append((module_name, path, program_text))
return out
else:
return [('__main__', 'main', program_text)]
def parse_module(
self, program_text: str,
incremental_step: int) -> List[Tuple[str, str, Optional[str]]]:
"""Return the module and program names for a test case.
Normally, the unit tests will parse the default ('__main__')
module and follow all the imports listed there. You can override
this behavior and instruct the tests to check multiple modules
by using a comment like this in the test case input:
# cmd: mypy -m foo.bar foo.baz
You can also use `# cmdN:` to have a different cmd for incremental
step N (2, 3, ...).
Return a list of tuples (module name, file name, program text).
"""
m = re.search('# cmd: mypy -m ([a-zA-Z0-9_. ]+)$',
program_text,
flags=re.MULTILINE)
regex = '# cmd{}: mypy -m ([a-zA-Z0-9_. ]+)$'.format(incremental_step)
alt_m = re.search(regex, program_text, flags=re.MULTILINE)
if alt_m is not None and incremental_step > 1:
# Optionally return a different command if in a later step
# of incremental mode, otherwise default to reusing the
# original cmd.
m = alt_m
if m:
# The test case wants to use a non-default main
# module. Look up the module and give it as the thing to
# analyze.
module_names = m.group(1)
out = [] # type: List[Tuple[str, str, Optional[str]]]
for module_name in module_names.split(' '):
path = build.find_module(module_name, [test_temp_dir])
if path is None and module_name.startswith(
NON_EXISTENT_PREFIX):
# This is a special name for a file that we don't want to exist.
assert '.' not in module_name # TODO: Packages not supported here
if module_name.endswith(STUB_SUFFIX):
fnam = '{}.pyi'.format(module_name)
else:
fnam = '{}.py'.format(module_name)
path = os.path.join(test_temp_dir, fnam)
out.append((module_name, path, None))
else:
assert path is not None, "Can't find ad hoc case file for %r" % module_name
with open(path) as f:
program_text = f.read()
out.append((module_name, path, program_text))
return out
else:
return [('__main__', 'main', program_text)]
def parse_module(self,
program_text: str,
incremental_step: int = 0) -> List[Tuple[str, str, str]]:
"""Return the module and program names for a test case.
Normally, the unit tests will parse the default ('__main__')
module and follow all the imports listed there. You can override
this behavior and instruct the tests to check multiple modules
by using a comment like this in the test case input:
# cmd: mypy -m foo.bar foo.baz
You can also use `# cmdN:` to have a different cmd for incremental
step N (2, 3, ...).
Return a list of tuples (module name, file name, program text).
"""
m = re.search('# cmd: mypy -m ([a-zA-Z0-9_. ]+)$',
program_text,
flags=re.MULTILINE)
regex = '# cmd{}: mypy -m ([a-zA-Z0-9_. ]+)$'.format(incremental_step)
alt_m = re.search(regex, program_text, flags=re.MULTILINE)
if alt_m is not None and incremental_step > 1:
# Optionally return a different command if in a later step
# of incremental mode, otherwise default to reusing the
# original cmd.
m = alt_m
if m:
# The test case wants to use a non-default main
# module. Look up the module and give it as the thing to
# analyze.
module_names = m.group(1)
out = []
for module_name in module_names.split(' '):
path = build.find_module(module_name, [test_temp_dir])
assert path is not None, "Can't find ad hoc case file"
with open(path) as f:
program_text = f.read()
out.append((module_name, path, program_text))
return out
else:
return [('__main__', 'main', program_text)]
def parse_module(self,
program_text: str,
incremental_step: int) -> List[Tuple[str, str, str]]:
"""Return the module and program names for a test case.
Normally, the unit tests will parse the default ('__main__')
module and follow all the imports listed there. You can override
this behavior and instruct the tests to check multiple modules
by using a comment like this in the test case input:
# cmd: mypy -m foo.bar foo.baz
You can also use `# cmdN:` to have a different cmd for incremental
step N (2, 3, ...).
Return a list of tuples (module name, file name, program text).
"""
m = re.search('# cmd: mypy -m ([a-zA-Z0-9_. ]+)$', program_text, flags=re.MULTILINE)
regex = '# cmd{}: mypy -m ([a-zA-Z0-9_. ]+)$'.format(incremental_step)
alt_m = re.search(regex, program_text, flags=re.MULTILINE)
if alt_m is not None and incremental_step > 1:
# Optionally return a different command if in a later step
# of incremental mode, otherwise default to reusing the
# original cmd.
m = alt_m
if m:
# The test case wants to use a non-default main
# module. Look up the module and give it as the thing to
# analyze.
module_names = m.group(1)
out = []
for module_name in module_names.split(' '):
path = build.find_module(module_name, [test_temp_dir])
assert path is not None, "Can't find ad hoc case file"
with open(path) as f:
program_text = f.read()
out.append((module_name, path, program_text))
return out
else:
return [('__main__', 'main', program_text)]
def parse_options(self, program_text: str) -> Tuple[str, str, str]:
"""Return type check options for a test case.
The default ('__main__') module name can be overridden by
using a comment like this in the test case input:
# cmd: mypy -m foo.bar
Return tuple (main module name, main file name, main program text).
"""
m = re.search('# cmd: mypy -m ([a-zA-Z0-9_.]+) *$', program_text, flags=re.MULTILINE)
if m:
# The test case wants to use a non-default main
# module. Look up the module and give it as the thing to
# analyze.
module_name = m.group(1)
path = build.find_module(module_name, [test_temp_dir])
with open(path) as f:
program_text = f.read()
return m.group(1), path, program_text
else:
return '__main__', 'main', program_text