def InferAndCheck(self, code): errorlog = errors.ErrorLog() unit = infer.infer_types( textwrap.dedent(code), self.PYTHON_VERSION, errorlog, deep=True, reverse_operators=True, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit), errorlog
def _InferAndVerify(self, src, pythonpath=(), module_name=None, imports_map=None, report_errors=False, quick=False, **kwargs): """Infer types for the source code treating it as a module. Used by Infer(). Args: src: The source code of a module. Treat it as "__main__". pythonpath: --pythonpath as list/tuple of string module_name: Name of the module we're analyzing. E.g. "foo.bar.mymodule". imports_map: --imports_info data report_errors: Whether to fail if the type inferencer reports any errors in the program. quick: Try to run faster, by avoiding costly computations. **kwargs: Keyword paramters to pass through to the type inferencer. Raises: AssertionError: If report_errors is True and we found errors. Returns: A pytd.TypeDeclUnit """ self.options.tweak(pythonpath=pythonpath, module_name=module_name, imports_map=imports_map, quick=quick) errorlog = self._InitErrorLog(src) unit = infer.infer_types(src, errorlog, self.options, **kwargs) unit = pytd_utils.CanonicalOrdering(unit.Visit(visitors.VerifyVisitor())) if report_errors and errorlog.has_error(): errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog)) return unit
def InferFromFile(self, filename, pythonpath): self.options.tweak(pythonpath=pythonpath) with open(filename, "rb") as fi: unit = infer.infer_types(fi.read(), self.errorlog, self.options, filename=filename, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def InferAndCheck(self, code): errorlog = errors.ErrorLog() unit = infer.infer_types( textwrap.dedent(code), self.PYTHON_VERSION, errorlog, deep=True, solve_unknowns=True, reverse_operators=True, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit), errorlog
def _InferAndVerify(self, src, pythonpath=(), imports_map=None, report_errors=False, **kwargs): """Infer types for the source code treating it as a module. Used by class Infer (which sets up a 'with' framework) Args: src: The source code of a module. Treat it as "__main__". pythonpath: --pythonpath as list/tuple of string imports_map: --imports_info data report_errors: Whether to fail if the type inferencer reports any errors in the program. **kwargs: Keyword paramters to pass through to the type inferencer. Raises: AssertionError: If report_errors is True and we found errors. Returns: A pytd.TypeDeclUnit """ self.options.tweak(pythonpath=pythonpath, imports_map=imports_map) errorlog = self._InitErrorLog(src) unit = infer.infer_types(src, errorlog, self.options, **kwargs) unit = pytd_utils.CanonicalOrdering(unit.Visit(visitors.VerifyVisitor())) if report_errors and errorlog.has_error(): errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog)) return unit
def InferAndCheck(self, code): unit = infer.infer_types( textwrap.dedent(code), self.errorlog, self.options, deep=True, reverse_operators=True, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit), self.errorlog
def InferAndCheck(self, code, deep=True, pythonpath=(), **kwargs): self.options.tweak(pythonpath=pythonpath) code = textwrap.dedent(code) errorlog = self._InitErrorLog(code) unit = infer.infer_types( code, errorlog, self.options, deep=deep, cache_unknowns=True, **kwargs) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit), errorlog
def InferAndCheck(self, code, deep=True, pythonpath=()): self.options.tweak(pythonpath=pythonpath) code = textwrap.dedent(code) errorlog = self._InitErrorLog(code) unit = infer.infer_types( code, errorlog, self.options, deep=deep, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit), errorlog
def InferFromFile(self, filename, pythonpath, find_pytd_import_ext=".pytd"): with open(filename, "rb") as fi: unit = infer.infer_types(fi.read(), self.PYTHON_VERSION, filename=filename, cache_unknowns=True, pythonpath=pythonpath, find_pytd_import_ext=find_pytd_import_ext) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def InferFromFile(self, filename, pythonpath): self.options.tweak(pythonpath=pythonpath) with open(filename, "rb") as fi: code = fi.read() errorlog = self._InitErrorLog(code, filename) unit = infer.infer_types(code, errorlog, self.options, filename=filename, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def InferFromFile(self, filename, pythonpath, find_pytd_import_ext=".pytd"): errorlog = errors.ErrorLog() with open(filename, "rb") as fi: unit = infer.infer_types(fi.read(), self.PYTHON_VERSION, errorlog, filename=filename, cache_unknowns=True, pythonpath=pythonpath, find_pytd_import_ext=find_pytd_import_ext) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def assert_ok(self, code, raises=None, pythonpath=(), find_pytd_import_ext=".pytd"): """Run an inference smoke test for the given code.""" if raises is not None: # TODO(kramm): support this log.warning("Ignoring 'raises' parameter to assert_ok") unit = infer.infer_types( textwrap.dedent(code), self.PYTHON_VERSION, deep=False, solve_unknowns=False, reverse_operators=True, pythonpath=pythonpath, find_pytd_import_ext=find_pytd_import_ext, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def InferFromFile(self, filename, pythonpath): self.options.tweak(pythonpath=pythonpath) with open(filename, "rb") as fi: code = fi.read() errorlog = errors.ErrorLog() loader = load_pytd.Loader( infer.get_module_name(filename, self.options), self.options) unit, _ = infer.infer_types(code, errorlog, self.options, loader=loader, filename=filename, cache_unknowns=True) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def _InferAndVerify(self, src, **kwargs): """Infer types for the source code treating it as a module. Used by class Infer (which sets up a 'with' framework) Args: src: The source code of a module. Treat it as "__main__". **kwargs: Keyword paramters to pass through to the type inferencer. Returns: A pytd.TypeDeclUnit """ unit = infer.infer_types(src, self.PYTHON_VERSION, **kwargs) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def assertNoErrors(self, code, raises=None, pythonpath=(), report_errors=True): """Run an inference smoke test for the given code.""" if raises is not None: # TODO(kramm): support this log.warning("Ignoring 'raises' parameter to assertNoErrors") self.options.tweak(pythonpath=pythonpath) errorlog = self._InitErrorLog(code) unit = infer.infer_types( textwrap.dedent(code), errorlog, self.options, deep=True, solve_unknowns=True, cache_unknowns=True) if report_errors and errorlog.has_error(): errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog)) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def assertNoErrors(self, code, raises=None, pythonpath=(), report_errors=True): """Run an inference smoke test for the given code.""" if raises is not None: # TODO(kramm): support this log.warning("Ignoring 'raises' parameter to assertNoErrors") self.options.tweak(pythonpath=pythonpath) unit = infer.infer_types( textwrap.dedent(code), self.errorlog, self.options, deep=False, solve_unknowns=False, reverse_operators=True, cache_unknowns=True) if report_errors and self.errorlog.errors: self.errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(self.errorlog)) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def assertNoErrors(self, code, raises=None, pythonpath=(), find_pytd_import_ext=".pytd", report_errors=True): """Run an inference smoke test for the given code.""" if raises is not None: # TODO(kramm): support this log.warning("Ignoring 'raises' parameter to assertNoErrors") errorlog = errors.ErrorLog() unit = infer.infer_types( textwrap.dedent(code), self.PYTHON_VERSION, errorlog, deep=False, solve_unknowns=False, reverse_operators=True, pythonpath=pythonpath, find_pytd_import_ext=find_pytd_import_ext, cache_unknowns=True) if report_errors and errorlog.errors: errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog.errors)) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def assertNoErrors(self, code, raises=None, pythonpath=(), find_pytd_import_ext=".pytd", report_errors=True): """Run an inference smoke test for the given code.""" if raises is not None: # TODO(kramm): support this log.warning("Ignoring 'raises' parameter to assertNoErrors") errorlog = errors.ErrorLog() unit = infer.infer_types( textwrap.dedent(code), self.PYTHON_VERSION, errorlog, deep=False, solve_unknowns=False, reverse_operators=True, pythonpath=pythonpath, find_pytd_import_ext=find_pytd_import_ext, cache_unknowns=True) if report_errors and errorlog.errors: errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog)) unit.Visit(visitors.VerifyVisitor()) return pytd_utils.CanonicalOrdering(unit)
def InferAndCheck(self, code, deep=True, pythonpath=(), **kwargs): self.options.tweak(pythonpath=pythonpath) code = textwrap.dedent(code) errorlog = errors.ErrorLog() unit, builtins_pytd = infer.infer_types(code, errorlog, self.options, deep=deep, analyze_annotated=True, cache_unknowns=True, **kwargs) unit.Visit(visitors.VerifyVisitor()) unit = optimize.Optimize(unit, builtins_pytd, lossy=False, use_abcs=False, max_union=7, remove_mutable=False) return pytd_utils.CanonicalOrdering(unit), errorlog
def _InferAndVerify(self, src, report_errors=False, **kwargs): """Infer types for the source code treating it as a module. Used by class Infer (which sets up a 'with' framework) Args: src: The source code of a module. Treat it as "__main__". report_errors: Whether to fail if the type inferencer reports any errors in the program. **kwargs: Keyword paramters to pass through to the type inferencer. Raises: AssertionError: If report_errors is True and we found errors. Returns: A pytd.TypeDeclUnit """ errorlog = errors.ErrorLog() unit = infer.infer_types(src, self.PYTHON_VERSION, errorlog, **kwargs) unit = pytd_utils.CanonicalOrdering(unit.Visit(visitors.VerifyVisitor())) if report_errors and errorlog.errors: errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog.errors)) return unit
def _InferAndVerify(self, src, report_errors=False, **kwargs): """Infer types for the source code treating it as a module. Used by class Infer (which sets up a 'with' framework) Args: src: The source code of a module. Treat it as "__main__". report_errors: Whether to fail if the type inferencer reports any errors in the program. **kwargs: Keyword paramters to pass through to the type inferencer. Raises: AssertionError: If report_errors is True and we found errors. Returns: A pytd.TypeDeclUnit """ errorlog = errors.ErrorLog() unit = infer.infer_types(src, self.PYTHON_VERSION, errorlog, **kwargs) unit = pytd_utils.CanonicalOrdering(unit.Visit(visitors.VerifyVisitor())) if report_errors and errorlog: errorlog.print_to_stderr() self.fail("Inferencer found %d errors" % len(errorlog)) return unit