def test_verbosity(self):
level = logging.getLogger().getEffectiveLevel()
# make sure we properly exercise verbosity_from by changing the log level
assert level != logging.ERROR
with config.verbosity_from(config.Options.create(verbosity=1)):
self.assertEqual(logging.getLogger().getEffectiveLevel(), logging.ERROR)
self.assertEqual(logging.getLogger().getEffectiveLevel(), level)
def trace(src, options=None):
"""Generates type traces for the given source code.
Args:
src: The source text.
options: A pytype.config.Options object that can be used to specify options
such as the target Python version.
Returns:
A source.Code object.
"""
errorlog = errors.ErrorLog()
options = options or config.Options.create()
with config.verbosity_from(options):
loader = load_pytd.create_loader(options)
vm = analyze.CallTracer(errorlog=errorlog,
options=options,
generate_unknowns=options.protocols,
loader=loader)
pytd_module, _ = analyze.infer_types(src=src,
filename=options.input,
errorlog=errorlog,
options=options,
loader=loader,
tracer_vm=vm)
raw_traces = []
for op, symbol, data in vm.opcode_traces:
raw_traces.append(
(op, symbol,
tuple(_to_pytd(d, loader, pytd_module) for d in data)))
return source.Code(src, raw_traces, TypeTrace, options.input)
def run_pytype(*, filename: str, python_version: str,
typeshed_location: str) -> Optional[str]:
"""Runs pytype, returning the stderr if any."""
if python_version not in _LOADERS:
options = pytype_config.Options.create("",
parse_pyi=True,
python_version=python_version)
loader = load_pytd.create_loader(options)
_LOADERS[python_version] = (options, loader)
options, loader = _LOADERS[python_version]
old_typeshed_home = os.environ.get(TYPESHED_HOME, UNSET)
os.environ[TYPESHED_HOME] = typeshed_location
try:
with pytype_config.verbosity_from(options):
ast = loader.load_file(_get_module_name(filename), filename)
loader.finish_and_verify_ast(ast)
except Exception:
stderr = traceback.format_exc()
else:
stderr = None
if old_typeshed_home is UNSET:
del os.environ[TYPESHED_HOME]
else:
os.environ[TYPESHED_HOME] = old_typeshed_home
return stderr
def check_py(input_filename, options=None, loader=None):
"""Check the types of one file."""
options = options or config.Options.create(input_filename)
with config.verbosity_from(options):
errorlog, _ = _call(analyze.check_types, input_filename, options,
loader)
return errorlog
def run_pytype(*, filename: str, python_version: str,
typeshed_location: str) -> str | None:
"""Runs pytype, returning the stderr if any."""
if python_version not in _LOADERS:
options = pytype_config.Options.create("",
parse_pyi=True,
python_version=python_version)
loader = load_pytd.create_loader(options)
_LOADERS[python_version] = (options, loader)
options, loader = _LOADERS[python_version]
stderr: str | None
try:
with pytype_config.verbosity_from(options):
ast = loader.load_file(_get_module_name(filename), filename)
loader.finish_and_verify_ast(ast)
except Exception:
stderr = traceback.format_exc()
else:
stderr = None
return stderr
def generate_pyi(src, options=None, loader=None):
"""Run the inferencer on a string of source code, producing output.
Args:
src: The source code.
options: config.Options object.
loader: A load_pytd.Loader instance.
Returns:
A tuple, (errors.ErrorLog, PYI Ast as string, TypeDeclUnit).
Raises:
CompileError: If we couldn't parse the input file.
UsageError: If the input filepath is invalid.
"""
options = options or config.Options.create()
with config.verbosity_from(options):
errorlog, (mod, builtins) = _call(analyze.infer_types, src, options,
loader)
mod.Visit(visitors.VerifyVisitor())
mod = optimize.Optimize(
mod,
builtins,
# TODO(b/159038508): Add FLAGs for these
lossy=False,
use_abcs=False,
max_union=7,
remove_mutable=False)
mod = pytd_utils.CanonicalOrdering(mod, sort_signatures=True)
result = pytd_utils.Print(mod)
log.info("=========== pyi optimized =============")
log.info("\n%s", result)
log.info("========================================")
result += "\n"
if options.quick:
result = "# (generated with --quick)\n\n" + result
return errorlog, result, mod
def check_py(src, options=None, loader=None):
"""Check the types of a string of source code."""
options = options or config.Options.create()
with config.verbosity_from(options):
errorlog, _ = _call(analyze.check_types, src, options, loader)
return errorlog
def wrapper(*args, **kwargs):
options = kwargs.get("options", args[posarg])
with config.verbosity_from(options):
return f(*args, **kwargs)
def process_file(options,
source_text=None,
generate_callgraphs=False,
preserve_pytype_vm=False):
"""Process a single file and return cross references.
Args:
options: A dictionary of pytype options.
source_text: Optional text of the file; will be read from the file pointed
to by options.input if not supplied.
generate_callgraphs: Collect call graph information
preserve_pytype_vm: Preserve the pytype vm in the indexer
Returns:
The Indexer object used for indexing.
Raises:
PytypeError if pytype fails.
"""
with config.verbosity_from(options):
errorlog = errors.ErrorLog()
loader = load_pytd.create_loader(options)
src = source_text or io.read_source_file(options.input)
vm = analyze.CallTracer(errorlog=errorlog,
options=options,
generate_unknowns=options.protocols,
store_all_calls=True,
loader=loader)
with io.wrap_pytype_exceptions(PytypeError, filename=options.input):
pytd_module, _ = analyze.infer_types(src=src,
filename=options.input,
errorlog=errorlog,
options=options,
loader=loader,
tracer_vm=vm)
major, minor = options.python_version
if major == 2:
# python2.7 is the only supported py2 version.
ast_root_node = ast27.parse(src, options.input)
ast = ast27
else:
ast_root_node = ast3.parse(src, options.input, feature_version=minor)
ast = ast3
# TODO(mdemello): Get from args
module_name = "module"
src_code = source.Code(src,
vm.opcode_traces,
VmTrace,
filename=options.input)
ix = Indexer(ast=ast,
src=src_code,
loader=vm.loader,
module_name=module_name,
pytd_module=pytd_module)
ix.index(ast_root_node)
ix.finalize()
# Make the vm available via indexer.vm for post-finalize() functions.
ix.vm = vm
# Use the indexer as a single object to hold data for calling processes.
if generate_callgraphs:
ix.function_map = callgraph.collect_function_map(ix)
# Release the vm before returning
if not preserve_pytype_vm:
ix.vm = None
return ix
