def testCreateTypeParametersFromUnknowns(self): src = textwrap.dedent(""" from typing import Dict def f(x: `~unknown1`) -> `~unknown1`: ... def g(x: `~unknown2`, y: `~unknown2`) -> None: ... def h(x: `~unknown3`) -> None: ... def i(x: Dict[`~unknown4`, `~unknown4`]) -> None: ... # Should not be changed class `~unknown5`(object): def __add__(self, x: `~unknown6`) -> `~unknown6`: ... def `~f`(x: `~unknown7`) -> `~unknown7`: ... """) expected = textwrap.dedent(""" from typing import Dict _T0 = TypeVar('_T0') def f(x: _T0) -> _T0: ... def g(x: _T0, y: _T0) -> None: ... def h(x: `~unknown3`) -> None: ... def i(x: Dict[_T0, _T0]) -> None: ... class `~unknown5`(object): def __add__(self, x: `~unknown6`) -> `~unknown6`: ... def `~f`(x: `~unknown7`) -> `~unknown7`: ... """) ast1 = self.Parse(src) ast1 = ast1.Visit(visitors.CreateTypeParametersForSignatures()) self.AssertSourceEquals(ast1, expected)
def testKeepCustomNew(self): src = textwrap.dedent(""" class Foo: def __new__(cls: Type[X]) -> X: ... class Bar: def __new__(cls, x: Type[Bar]) -> Bar: ... """).strip() ast = self.Parse(src).Visit(visitors.CreateTypeParametersForSignatures()) self.assertMultiLineEqual(pytd.Print(ast), src)
def testRedefineTypeVar(self): src = textwrap.dedent(""" def f(x: `~unknown1`) -> `~unknown1`: ... class `TypeVar`(object): ... """) ast = self.Parse(src).Visit(visitors.CreateTypeParametersForSignatures()) self.assertMultiLineEqual(pytd.Print(ast), textwrap.dedent(""" import typing _T0 = TypeVar('_T0') class `TypeVar`(object): ... def f(x: _T0) -> _T0: ...""").strip())
def testCreateTypeParametersForNew(self): src = textwrap.dedent(""" class Foo: def __new__(cls: Type[Foo]) -> Foo class Bar: def __new__(cls: Type[Bar], x, y, z) -> Bar """) ast = self.Parse(src).Visit(visitors.CreateTypeParametersForSignatures()) self.assertMultiLineEqual(pytd.Print(ast), textwrap.dedent(""" from typing import TypeVar _TBar = TypeVar('_TBar', bound=Bar) _TFoo = TypeVar('_TFoo', bound=Foo) class Foo: def __new__(cls: Type[_TFoo]) -> _TFoo: ... class Bar: def __new__(cls: Type[_TBar], x, y, z) -> _TBar: ... """).strip())
def infer_types(src, errorlog, options, loader, filename=None, deep=True, init_maximum_depth=INIT_MAXIMUM_DEPTH, show_library_calls=False, maximum_depth=None, tracer_vm=None, **kwargs): """Given Python source return its types. Args: src: A string containing Python source code. errorlog: Where error messages go. Instance of errors.ErrorLog. options: config.Options object loader: A load_pytd.Loader instance to load PYI information. filename: Filename of the program we're parsing. deep: If True, analyze all functions, even the ones not called by the main execution flow. init_maximum_depth: Depth of analysis during module loading. show_library_calls: If True, call traces are kept in the output. maximum_depth: Depth of the analysis. Default: unlimited. tracer_vm: An instance of CallTracer, in case the caller wants to instantiate and retain the vm used for type inference. **kwargs: Additional parameters to pass to vm.VirtualMachine Returns: A tuple of (ast: TypeDeclUnit, builtins: TypeDeclUnit) Raises: AssertionError: In case of a bad parameter combination. """ # If the caller has passed in a vm, use that. if tracer_vm: assert isinstance(tracer_vm, CallTracer) tracer = tracer_vm else: tracer = CallTracer(errorlog=errorlog, options=options, generate_unknowns=options.protocols, store_all_calls=not deep, loader=loader, **kwargs) loc, defs = tracer.run_program(src, filename, init_maximum_depth) log.info("===Done running definitions and module-level code===") snapshotter = metrics.get_metric("memory", metrics.Snapshot) snapshotter.take_snapshot("analyze:infer_types:tracer") if deep: if maximum_depth is None: if not options.quick: maximum_depth = MAXIMUM_DEPTH elif options.analyze_annotated: # Since there's no point in analyzing annotated functions for inference, # the presence of this option means that the user wants checking, too. maximum_depth = QUICK_CHECK_MAXIMUM_DEPTH else: maximum_depth = QUICK_INFER_MAXIMUM_DEPTH tracer.exitpoint = tracer.analyze(loc, defs, maximum_depth) else: tracer.exitpoint = loc snapshotter.take_snapshot("analyze:infer_types:post") ast = tracer.compute_types(defs) ast = tracer.loader.resolve_ast(ast) if tracer.has_unknown_wildcard_imports or any( a in defs for a in abstract_utils.DYNAMIC_ATTRIBUTE_MARKERS): try: ast.Lookup("__getattr__") except KeyError: ast = pytd_utils.Concat( ast, builtins.GetDefaultAst(options.python_version)) # If merged with other if statement, triggers a ValueError: Unresolved class # when attempts to load from the protocols file if options.protocols: protocols_pytd = tracer.loader.import_name("protocols") else: protocols_pytd = None builtins_pytd = tracer.loader.concat_all() # Insert type parameters, where appropriate ast = ast.Visit(visitors.CreateTypeParametersForSignatures()) if options.protocols: log.info("=========== PyTD to solve =============\n%s", pytd_utils.Print(ast)) ast = convert_structural.convert_pytd(ast, builtins_pytd, protocols_pytd) elif not show_library_calls: log.info("Solving is turned off. Discarding call traces.") # Rename remaining "~unknown" to "?" ast = ast.Visit(visitors.RemoveUnknownClasses()) # Remove "~list" etc.: ast = convert_structural.extract_local(ast) _maybe_output_debug(options, tracer.program) return ast, builtins_pytd