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]))
