def testPrecompilation(self): # Get original (non-precompiled) values. b1, t1 = builtins.GetBuiltinsAndTyping() # Write precompiled data. precompiled = cStringIO.StringIO() builtins.Precompile(precompiled) # Clear the cache builtins._cached_builtins_pytd = None # Load precompiled data. builtins.LoadPrecompiled(cStringIO.StringIO(precompiled.getvalue())) self.assertIsNotNone(builtins._cached_builtins_pytd) b2, t2 = builtins.GetBuiltinsAndTyping() self.assertEquals(pytd.Print(b1), pytd.Print(b2)) self.assertEquals(pytd.Print(t1), pytd.Print(t2))
def testPrecompilation(self): # Get original (non-precompiled) values. b1, t1 = builtins.GetBuiltinsAndTyping() # Write precompiled data. with utils.Tempdir() as d: precompiled = os.path.join(d.path, "precompiled.pickle") builtins.Precompile(precompiled) # Clear the cache builtins._cached_builtins_pytd = None # Load precompiled data. builtins.LoadPrecompiled(precompiled) self.assertIsNotNone(builtins._cached_builtins_pytd) b2, t2 = builtins.GetBuiltinsAndTyping() self.assertEqual(pytd.Print(b1), pytd.Print(b2)) self.assertEqual(pytd.Print(t1), pytd.Print(t2))
def assertTypesMatchPytd(self, ty, pytd_src, version=None): """Parses pytd_src and compares with ty.""" pytd_tree = parser.parse_string(textwrap.dedent(pytd_src), python_version=version) pytd_tree = pytd_tree.Visit( visitors.LookupBuiltins(builtins.GetBuiltinsAndTyping()[0], full_names=False)) pytd_tree = pytd_tree.Visit(visitors.LookupLocalTypes()) pytd_tree = pytd_tree.Visit(visitors.ClassTypeToNamedType()) pytd_tree = pytd_tree.Visit( visitors.CanonicalOrderingVisitor(sort_signatures=True)) pytd_tree.Visit(visitors.VerifyVisitor()) ty = ty.Visit(visitors.ClassTypeToNamedType()) ty = ty.Visit(visitors.AdjustSelf(force=True)) ty = ty.Visit(visitors.CanonicalOrderingVisitor(sort_signatures=True)) ty.Visit(visitors.VerifyVisitor()) ty_src = pytd.Print(ty) + "\n" pytd_tree_src = pytd.Print(pytd_tree) + "\n" log.info("========== result ==========") _LogLines(log.info, ty_src) log.info("========== expected ==========") _LogLines(log.info, pytd_tree_src) log.info("==============================") # In the diff output, mark expected with "-" and actual with "+". # (In other words, display a change from "working" to "broken") self.assertMultiLineEqual(pytd_tree_src, ty_src)
def __init__(self, base_module, python_version, pythonpath=(), imports_map=None, use_typeshed=True, typeshed_location="typeshed"): self.base_module = base_module self.python_version = python_version self.pythonpath = pythonpath self.imports_map = imports_map self.use_typeshed = use_typeshed self.typeshed_location = typeshed_location self.builtins, self.typing = builtins.GetBuiltinsAndTyping(python_version) self._modules = { "__builtin__": Module("__builtin__", self.PREFIX + "__builtin__", self.builtins, dirty=False), "typing": Module("typing", self.PREFIX + "typing", self.typing, dirty=False) } self._concatenated = None self._import_name_cache = {} # performance cache # Paranoid verification that pytype.main properly checked the flags: if imports_map is not None: assert pythonpath == [""], pythonpath
def assertTypesMatchPytd(self, ty, pytd_src, version=None): """Parses pytd_src and compares with ty.""" # TODO(pludemann): This is a copy of pytd.parse.parser_test_base.Parse() # TODO(pludemann): Consider using the pytd_tree to call # assertHasOnlySignatures (or similar) to guard against the # inferencer adding additional but harmless calls. pytd_tree = parser.TypeDeclParser(version=version).Parse( textwrap.dedent(pytd_src)) pytd_tree = pytd_tree.Visit( visitors.LookupBuiltins(builtins.GetBuiltinsAndTyping()[0])) pytd_tree = pytd_tree.Visit( visitors.ClassTypeToNamedType()) pytd_tree = pytd_tree.Visit( visitors.CanonicalOrderingVisitor(sort_signatures=True)) pytd_tree.Visit(visitors.VerifyVisitor()) ty = ty.Visit(visitors.ClassTypeToNamedType()) ty = ty.Visit(visitors.AdjustSelf(force=True)) ty = ty.Visit(visitors.CanonicalOrderingVisitor(sort_signatures=True)) ty.Visit(visitors.VerifyVisitor()) ty_src = pytd.Print(ty) + "\n" pytd_tree_src = pytd.Print(pytd_tree) + "\n" log.info("========== result ==========") _LogLines(log.info, ty_src) log.info("========== expected ==========") _LogLines(log.info, pytd_tree_src) log.info("==============================") # In the diff output, mark expected with "-" and actual with "+". # (In other words, display a change from "working" to "broken") self.assertMultiLineEqual(pytd_tree_src, ty_src)
def _base_modules(self, python_version): bltins, typing = builtins.GetBuiltinsAndTyping(python_version) return { "__builtin__": Module("__builtin__", self.PREFIX + "__builtin__", bltins, dirty=False), "typing": Module("typing", self.PREFIX + "typing", typing, dirty=False) }
def ParseWithBuiltins(self, src): ast = parser.TypeDeclParser().Parse(textwrap.dedent(src)) b, t = builtins.GetBuiltinsAndTyping() ast = ast.Visit(visitors.LookupExternalTypes( {"__builtin__": b, "typing": t}, full_names=True)) ast = ast.Visit(visitors.NamedTypeToClassType()) ast = visitors.AdjustTypeParameters(ast) ast.Visit(visitors.FillInModuleClasses({"": ast})) ast.Visit(visitors.VerifyVisitor()) return ast
def testGetBasesInMRO(self): ast = self.parser.Parse(textwrap.dedent(""" T = TypeVar("T") class Foo(Generic[T]): pass class Bar(Foo[int]): pass """)) b, t = builtins.GetBuiltinsAndTyping() ast = ast.Visit(visitors.LookupExternalTypes( {"__builtin__": b, "typing": t}, full_names=True)) ast = ast.Visit(visitors.NamedTypeToClassType()) mro = utils.GetBasesInMRO(ast.Lookup("Bar"), lookup_ast=ast) self.assertListEqual(["Foo", "typing.Generic", "__builtin__.object"], [t.name for t in mro])
def ParseWithBuiltins(self, src): ast = parser.parse_string(textwrap.dedent(src)) b, t = builtins.GetBuiltinsAndTyping() ast = ast.Visit( visitors.LookupExternalTypes({ "__builtin__": b, "typing": t }, full_names=True)) ast = ast.Visit(visitors.NamedTypeToClassType()) ast = ast.Visit(visitors.AdjustTypeParameters()) ast.Visit(visitors.FillInLocalPointers({"": ast, "__builtin__": b})) ast.Visit(visitors.VerifyVisitor()) return ast
def __init__(self, base_module, options): self.base_module = base_module self.options = options self.builtins, self.typing = builtins.GetBuiltinsAndTyping() self._modules = { "__builtin__": Module("__builtin__", self.PREFIX + "__builtin__", self.builtins), "typing": Module("typing", self.PREFIX + "typing", self.typing) } self._concatenated = None # Paranoid verification that pytype.main properly checked the flags: if self.options.imports_map is not None: assert self.options.pythonpath == [""]
def __init__(self, base_module, options): self.base_module = base_module self.options = options self.builtins, self.typing = builtins.GetBuiltinsAndTyping() self._modules = { "__builtin__": Module("__builtin__", self.PREFIX + "__builtin__", self.builtins), "typing": Module("typing", self.PREFIX + "typing", self.typing) } # Map from file paths to loaded modules in order to detect congruent # modules via an imports_map. self._path_to_module = {} self._concatenated = None # Paranoid verification that pytype.main properly checked the flags: if self.options.imports_map is not None: assert self.options.pythonpath == [""]
def __init__(self, base_module, options): self.base_module = base_module self.options = options self.builtins, self.typing = builtins.GetBuiltinsAndTyping( options.python_version) self._modules = { "__builtin__": Module("__builtin__", self.PREFIX + "__builtin__", self.builtins, dirty=False), "typing": Module("typing", self.PREFIX + "typing", self.typing, dirty=False) } self._concatenated = None self._import_name_cache = {} # performance cache # Paranoid verification that pytype.main properly checked the flags: if self.options.imports_map is not None: assert self.options.pythonpath == [""], self.options.pythonpath
def testGetBasesInMRO(self): ast = parser.parse_string(textwrap.dedent(""" from typing import Generic, TypeVar T = TypeVar("T") class Foo(Generic[T]): pass class Bar(Foo[int]): pass """), python_version=self.PYTHON_VERSION) b, t = builtins.GetBuiltinsAndTyping(self.PYTHON_VERSION) ast = ast.Visit( visitors.LookupExternalTypes({ "__builtin__": b, "typing": t }, full_names=True)) ast = ast.Visit(visitors.NamedTypeToClassType()) bases = mro.GetBasesInMRO(ast.Lookup("Bar"), lookup_ast=ast) self.assertListEqual(["Foo", "typing.Generic", "__builtin__.object"], [t.name for t in bases])
def PrepareForExport(module_name, python_version, ast): """Prepare an ast as if it was parsed and loaded. External dependencies will not be resolved, as the ast generated by this method is supposed to be exported. Args: module_name: The module_name as a string for the returned ast. python_version: A tuple of (major, minor) python version as string (see config.python_version). ast: pytd.TypeDeclUnit, is only used if src is None. Returns: A pytd.TypeDeclUnit representing the supplied AST as it would look after being written to a file and parsed. """ # This is a workaround for functionality which crept into places it doesn't # belong. Ideally this would call some transformation Visitors on ast to # transform it into the same ast we get after parsing and loading (compare # load_pytd.Loader.load_file). Unfortunately parsing has some special cases, # e.g. '__init__' return type and '__new__' being a 'staticmethod', which # need to be moved to visitors before we can do this. Printing an ast also # applies transformations, # e.g. visitors.PrintVisitor._FormatContainerContents, which need to move to # their own visitors so they can be applied without printing. src = pytd_utils.Print(ast) ast = pytd_builtins.ParsePyTD(src=src, module=module_name, python_version=python_version) builtins, _ = pytd_builtins.GetBuiltinsAndTyping(python_version) ast = ast.Visit(visitors.LookupBuiltins(builtins, full_names=False)) ast = ast.Visit(visitors.ExpandCompatibleBuiltins(builtins)) ast = ast.Visit(visitors.LookupLocalTypes()) ast = ast.Visit(visitors.AdjustTypeParameters()) ast = ast.Visit(visitors.NamedTypeToClassType()) ast = ast.Visit(visitors.FillInLocalPointers({"": ast, module_name: ast})) ast = ast.Visit(visitors.CanonicalOrderingVisitor()) ast = ast.Visit( visitors.ClassTypeToLateType( ignore=[module_name + ".", "__builtin__.", "typing."])) return ast
def testExpandCompatibleBuiltins(self): b, _ = parser_builtins.GetBuiltinsAndTyping() src = textwrap.dedent(""" from typing import Tuple, Union def f1(a: float) -> None: ... def f2() -> float: ... def f3(a: bool) -> None: ... def f4() -> bool: ... def f5(a: unicode) -> None: ... def f6() -> unicode: ... def f7(a: Union[unicode, int]) -> None: ... def f8(a: Tuple[unicode, int]) -> None: ... """) expected = textwrap.dedent(""" from typing import Tuple, Union def f1(a: Union[float, int]) -> None: ... def f2() -> float: ... def f3(a: Union[bool, None]) -> None: ... def f4() -> bool: ... def f5(a: Union[unicode, str, bytes]) -> None: ... def f6() -> unicode: ... def f7(a: Union[unicode, bytes, str, int]) -> None: ... def f8(a: Tuple[Union[unicode, bytes, str], int]) -> None: ... """) src_tree, expected_tree = (self.Parse(s) .Visit(visitors.LookupBuiltins(b)) for s in (src, expected)) new_tree = src_tree.Visit(visitors.ExpandCompatibleBuiltins(b)) self.AssertSourceEquals(new_tree, expected_tree)
def parse(self, src): ast = parser.parse_string(textwrap.dedent(src)) ast = ast.Visit(visitors.LookupBuiltins( builtins.GetBuiltinsAndTyping(self.PYTHON_VERSION)[0])) return ast
def ParseAndResolve(self, src): ast = self.Parse(src) return ast.Visit( visitors.LookupBuiltins(builtins.GetBuiltinsAndTyping()[0]))