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