def test_borg(self): """test that the AstroidManager is really a borg, i.e. that two different instances has same cache""" first_manager = AstroidManager() built = first_manager.ast_from_module_name(BUILTINS) second_manager = AstroidManager() second_built = first_manager.ast_from_module_name(BUILTINS) self.assertIs(built, second_built)
def brainless_manager(self): manager = AstroidManager() # avoid caching into the AstroidManager borg since we get problems # with other tests : manager.__dict__ = {} manager.astroid_cache = {} manager._mod_file_cache = {} manager.transforms = {} return manager
def parse(self): manager = AstroidManager() project = manager.project_from_files(list(self.file_paths), func_wrapper=astroid_ignore_modname_wrapper) # First collect all definitions (e.g. module X, function foo) before # trying to relate one definition with another (e.g. module X depends on # module Y) DefsVisitor(self.modelers).visit(project) RelationsVisitor(self.modelers).visit(project)
class PyreverseAdapter(Run): """Integrate with pyreverse by overriding its CLI Run class to create diagram definitions that can be passed to a writer.""" def __init__(self, args): ConfigurationMixIn.__init__(self, usage=__doc__) insert_default_options() self.manager = AstroidManager() self.register_options_provider(self.manager) self.args = self.load_command_line_configuration() def run(self): if not self.args: print(self.help()) return # Insert current working directory to the python path to recognize # dependencies to local modules even if cwd is not in the PYTHONPATH. sys.path.insert(0, os.getcwd()) try: project = self.manager.project_from_files(self.args) linker = Linker(project, tag=True) handler = DiadefsHandler(self.config) diadefs = handler.get_diadefs(project, linker) finally: sys.path.pop(0) return diadefs
class Run(ConfigurationMixIn): """base class providing common behaviour for pyreverse commands""" options = OPTIONS def __init__(self, args): ConfigurationMixIn.__init__(self, usage=__doc__) insert_default_options() self.manager = AstroidManager() self.register_options_provider(self.manager) args = self.load_command_line_configuration() sys.exit(self.run(args)) def run(self, args): """checking arguments and run project""" if not args: print self.help() return 1 # insert current working directory to the python path to recognize # dependencies to local modules even if cwd is not in the PYTHONPATH sys.path.insert(0, os.getcwd()) try: project = self.manager.project_from_files(args) linker = Linker(project, tag=True) handler = DiadefsHandler(self.config) diadefs = handler.get_diadefs(project, linker) finally: sys.path.pop(0) if self.config.output_format == "vcg": writer.VCGWriter(self.config).write(diadefs) else: writer.DotWriter(self.config).write(diadefs) return 0
def __init__(self, args): ConfigurationMixIn.__init__(self, usage=__doc__) insert_default_options() self.manager = AstroidManager() self.register_options_provider(self.manager) args = self.load_command_line_configuration() sys.exit(self.run(args))
def brainless_manager(self): manager = AstroidManager() # avoid caching into the AstroidManager borg since we get problems # with other tests : manager.__dict__ = {} manager._failed_import_hooks = [] manager.astroid_cache = {} manager._mod_file_cache = {} manager._transform = transforms.TransformVisitor() manager.clear_cache() # trigger proper bootstraping return manager
def __init__(self, args,out_file='test.xml'): ConfigurationMixIn.__init__(self, usage=__doc__) IdGeneratorMixIn.__init__(self) insert_default_options() self.manager = AstroidManager() self.register_options_provider(self.manager) args = self.load_command_line_configuration() self._out_file = out_file self.run(args) pass
class AstroidManagerTC(TestCase): def setUp(self): self.manager = AstroidManager() self.manager.astroid_cache.clear() def test_ast_from_module(self): import unittest astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.pure_python, True) import time astroid = self.manager.ast_from_module(time) self.assertEqual(astroid.pure_python, False) def test_ast_from_class(self): astroid = self.manager.ast_from_class(int) self.assertEqual(astroid.name, 'int') self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object) self.assertEqual(astroid.name, 'object') self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn('__setattr__', astroid) def _test_ast_from_zip(self, archive): origpath = sys.path[:] sys.modules.pop('mypypa', None) archive_path = join(DATA, archive) sys.path.insert(0, archive_path) try: module = self.manager.ast_from_module_name('mypypa') self.assertEqual(module.name, 'mypypa') self.assertTrue(module.file.endswith('%s/mypypa' % archive), module.file) finally: # remove the module, else after importing egg, we don't get the zip if 'mypypa' in self.manager.astroid_cache: del self.manager.astroid_cache['mypypa'] del self.manager._mod_file_cache[('mypypa', None)] if archive_path in sys.path_importer_cache: del sys.path_importer_cache[archive_path] sys.path = origpath def test_ast_from_module_name_egg(self): self._test_ast_from_zip('MyPyPa-0.1.0-py2.5.egg') def test_ast_from_module_name_zip(self): self._test_ast_from_zip('MyPyPa-0.1.0-py2.5.zip') def test_from_directory(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, 'data') self.assertEqual(obj.name, 'data') self.assertEqual(obj.path, join(DATA, '__init__.py')) def test_project_node(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, 'data') expected = set(['SSL1', '__init__', 'all', 'appl', 'format', 'module', 'module2', 'noendingnewline', 'nonregr', 'notall']) expected = ['data', 'data.SSL1', 'data.SSL1.Connection1', 'data.absimport', 'data.all', 'data.appl', 'data.appl.myConnection', 'data.email', 'data.format', 'data.module', 'data.module2', 'data.noendingnewline', 'data.nonregr', 'data.notall'] self.assertListEqual(sorted(k for k in obj.keys()), expected) def test_do_not_expose_main(self): obj = self.manager.ast_from_module_name('__main__') self.assertEqual(obj.name, '__main__') self.assertEqual(obj.items(), [])
class AstroidManagerTC(TestCase): def setUp(self): self.manager = AstroidManager() self.manager.astroid_cache.clear() def test_ast_from_module(self): import unittest astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.pure_python, True) import time astroid = self.manager.ast_from_module(time) self.assertEqual(astroid.pure_python, False) def test_ast_from_class(self): astroid = self.manager.ast_from_class(int) self.assertEqual(astroid.name, "int") self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object) self.assertEqual(astroid.name, "object") self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn("__setattr__", astroid) def _test_ast_from_zip(self, archive): origpath = sys.path[:] sys.modules.pop("mypypa", None) archive_path = join(DATA, archive) sys.path.insert(0, archive_path) try: module = self.manager.ast_from_module_name("mypypa") self.assertEqual(module.name, "mypypa") self.assertTrue(module.file.endswith("%s/mypypa" % archive), module.file) finally: # remove the module, else after importing egg, we don't get the zip if "mypypa" in self.manager.astroid_cache: del self.manager.astroid_cache["mypypa"] del self.manager._mod_file_cache[("mypypa", None)] if archive_path in sys.path_importer_cache: del sys.path_importer_cache[archive_path] sys.path = origpath def test_ast_from_module_name_egg(self): self._test_ast_from_zip("MyPyPa-0.1.0-py2.5.egg") def test_ast_from_module_name_zip(self): self._test_ast_from_zip("MyPyPa-0.1.0-py2.5.zip") def test_from_directory(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, "data") self.assertEqual(obj.name, "data") self.assertEqual(obj.path, join(DATA, "__init__.py")) def test_project_node(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, "data") expected = set( ["SSL1", "__init__", "all", "appl", "format", "module", "module2", "noendingnewline", "nonregr", "notall"] ) expected = [ "data", "data.SSL1", "data.SSL1.Connection1", "data.absimport", "data.all", "data.appl", "data.appl.myConnection", "data.email", "data.format", "data.module", "data.module2", "data.noendingnewline", "data.nonregr", "data.notall", ] self.assertListEqual(sorted(k for k in list(obj.keys())), expected) def test_do_not_expose_main(self): obj = self.manager.ast_from_module_name("__main__") self.assertEqual(obj.name, "__main__") self.assertEqual(list(obj.items()), [])
def swapaxes(self, axis1, axis2): return np.ndarray([0, 0]) def take(self, indices, axis=None, out=None, mode='raise'): return np.ndarray([0, 0]) def tobytes(self, order='C'): return b'' def tofile(self, fid, sep="", format="%s"): return None def tolist(self, ): return [] def tostring(self, order='C'): return b'' def trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None): return np.ndarray([0, 0]) def transpose(self, *axes): return np.ndarray([0, 0]) def var(self, axis=None, dtype=None, out=None, ddof=0, keepdims=False): return np.ndarray([0, 0]) def view(self, dtype=None, type=None): return np.ndarray([0, 0]) """ if numpy_supports_type_hints(): ndarray += """ @classmethod def __class_getitem__(cls, value): return cls """ node = extract_node(ndarray) return node.infer(context=context) def _looks_like_numpy_ndarray(node): return isinstance(node, Attribute) and node.attrname == "ndarray" AstroidManager().register_transform( Attribute, inference_tip(infer_numpy_ndarray), _looks_like_numpy_ndarray, )
def infer_enum_class(node: nodes.ClassDef) -> nodes.ClassDef: """Specific inference for enums.""" for basename in (b for cls in node.mro() for b in cls.basenames): if node.root().name == "enum": # Skip if the class is directly from enum module. break dunder_members = {} target_names = set() for local, values in node.locals.items(): if any(not isinstance(value, nodes.AssignName) for value in values): continue stmt = values[0].statement(future=True) if isinstance(stmt, nodes.Assign): if isinstance(stmt.targets[0], nodes.Tuple): targets = stmt.targets[0].itered() else: targets = stmt.targets elif isinstance(stmt, nodes.AnnAssign): targets = [stmt.target] else: continue inferred_return_value = None if stmt.value is not None: if isinstance(stmt.value, nodes.Const): if isinstance(stmt.value.value, str): inferred_return_value = repr(stmt.value.value) else: inferred_return_value = stmt.value.value else: inferred_return_value = stmt.value.as_string() new_targets = [] for target in targets: if isinstance(target, nodes.Starred): continue target_names.add(target.name) # Replace all the assignments with our mocked class. classdef = dedent(""" class {name}({types}): @property def value(self): return {return_value} @property def name(self): return "{name}" """.format( name=target.name, types=", ".join(node.basenames), return_value=inferred_return_value, )) if "IntFlag" in basename: # Alright, we need to add some additional methods. # Unfortunately we still can't infer the resulting objects as # Enum members, but once we'll be able to do that, the following # should result in some nice symbolic execution classdef += INT_FLAG_ADDITION_METHODS.format( name=target.name) fake = AstroidBuilder( AstroidManager(), apply_transforms=False).string_build(classdef)[target.name] fake.parent = target.parent for method in node.mymethods(): fake.locals[method.name] = [method] new_targets.append(fake.instantiate_class()) dunder_members[local] = fake node.locals[local] = new_targets members = nodes.Dict(parent=node) members.postinit([(nodes.Const(k, parent=members), nodes.Name(v.name, parent=members)) for k, v in dunder_members.items()]) node.locals["__members__"] = [members] # The enum.Enum class itself defines two @DynamicClassAttribute data-descriptors # "name" and "value" (which we override in the mocked class for each enum member # above). When dealing with inference of an arbitrary instance of the enum # class, e.g. in a method defined in the class body like: # class SomeEnum(enum.Enum): # def method(self): # self.name # <- here # In the absence of an enum member called "name" or "value", these attributes # should resolve to the descriptor on that particular instance, i.e. enum member. # For "value", we have no idea what that should be, but for "name", we at least # know that it should be a string, so infer that as a guess. if "name" not in target_names: code = dedent(""" @property def name(self): return '' """) name_dynamicclassattr = AstroidBuilder( AstroidManager()).string_build(code)["name"] node.locals["name"] = [name_dynamicclassattr] break return node
def _proxied(self): # pylint: disable=method-hidden ast_builtins = AstroidManager().builtins_module return ast_builtins.getattr("frozenset")[0]
def setup_class(cls): cls._builtins = AstroidManager().astroid_cache.get("builtins")
# Astroid can't infer this attribute properly # Prevents https://github.com/PyCQA/pylint/issues/1884 node.locals["__attrs_attrs__"] = [Unknown(parent=node)] for cdef_body_node in node.body: if not isinstance(cdef_body_node, (Assign, AnnAssign)): continue if isinstance(cdef_body_node.value, Call): if cdef_body_node.value.func.as_string() not in ATTRIB_NAMES: continue else: continue targets = (cdef_body_node.targets if hasattr(cdef_body_node, "targets") else [cdef_body_node.target]) for target in targets: rhs_node = Unknown( lineno=cdef_body_node.lineno, col_offset=cdef_body_node.col_offset, parent=cdef_body_node, ) if isinstance(target, AssignName): # Could be a subscript if the code analysed is # i = Optional[str] = "" # See https://github.com/PyCQA/pylint/issues/4439 node.locals[target.name] = [rhs_node] node.instance_attrs[target.name] = [rhs_node] AstroidManager().register_transform(ClassDef, attr_attributes_transform, is_decorated_with_attrs)
def infer_namespace(node, context=None): callsite = arguments.CallSite.from_call(node, context=context) if not callsite.keyword_arguments: # Cannot make sense of it. raise UseInferenceDefault() class_node = nodes.ClassDef("Namespace", "docstring") class_node.parent = node.parent for attr in set(callsite.keyword_arguments): fake_node = nodes.EmptyNode() fake_node.parent = class_node fake_node.attrname = attr class_node.instance_attrs[attr] = [fake_node] return iter((class_node.instantiate_class(),)) def _looks_like_namespace(node): func = node.func if isinstance(func, nodes.Attribute): return ( func.attrname == "Namespace" and isinstance(func.expr, nodes.Name) and func.expr.name == "argparse" ) return False AstroidManager().register_transform( nodes.Call, inference_tip(infer_namespace), _looks_like_namespace )
def mechanize_transform(): return AstroidBuilder(AstroidManager()).string_build(""" class Browser(object): def __getattr__(self, name): return None def __getitem__(self, name): return None def __setitem__(self, name, val): return None def back(self, n=1): return None def clear_history(self): return None def click(self, *args, **kwds): return None def click_link(self, link=None, **kwds): return None def close(self): return None def encoding(self): return None def find_link(self, text=None, text_regex=None, name=None, name_regex=None, url=None, url_regex=None, tag=None, predicate=None, nr=0): return None def follow_link(self, link=None, **kwds): return None def forms(self): return None def geturl(self): return None def global_form(self): return None def links(self, **kwds): return None def open_local_file(self, filename): return None def open(self, url, data=None, timeout=None): return None def open_novisit(self, url, data=None, timeout=None): return None def open_local_file(self, filename): return None def reload(self): return None def response(self): return None def select_form(self, name=None, predicate=None, nr=None, **attrs): return None def set_cookie(self, cookie_string): return None def set_handle_referer(self, handle): return None def set_header(self, header, value=None): return None def set_html(self, html, url="http://example.com/"): return None def set_response(self, response): return None def set_simple_cookie(self, name, value, domain, path='/'): return None def submit(self, *args, **kwds): return None def title(self): return None def viewing_html(self): return None def visit_response(self, response, request=None): return None """)
# In this case, this will raise a ValueError raise UseInferenceDefault try: elts = random.sample(inferred_sequence.elts, length.value) except ValueError as exc: raise UseInferenceDefault from exc new_node = List(lineno=node.lineno, col_offset=node.col_offset, parent=node.scope()) new_elts = [ _clone_node_with_lineno(elt, parent=new_node, lineno=new_node.lineno) for elt in elts ] new_node.postinit(new_elts) return iter((new_node, )) def _looks_like_random_sample(node): func = node.func if isinstance(func, Attribute): return func.attrname == "sample" if isinstance(func, Name): return func.name == "sample" return False AstroidManager().register_transform(Call, inference_tip(infer_random_sample), _looks_like_random_sample)
def reload(self): return None def response(self): return None def select_form(self, name=None, predicate=None, nr=None, **attrs): return None def set_cookie(self, cookie_string): return None def set_handle_referer(self, handle): return None def set_header(self, header, value=None): return None def set_html(self, html, url="http://example.com/"): return None def set_response(self, response): return None def set_simple_cookie(self, name, value, domain, path='/'): return None def submit(self, *args, **kwds): return None def title(self): return None def viewing_html(self): return None def visit_response(self, response, request=None): return None """) register_module_extender(AstroidManager(), "mechanize", mechanize_transform)
def Array(typecode, sequence, lock=True): return array.array(typecode, sequence) class SyncManager(object): Queue = JoinableQueue = queue.Queue Event = threading.Event RLock = threading.RLock BoundedSemaphore = threading.BoundedSemaphore Condition = threading.Condition Barrier = threading.Barrier Pool = pool.Pool list = list dict = dict Value = Value Array = Array Namespace = Namespace __enter__ = lambda self: self __exit__ = lambda *args: args def start(self, initializer=None, initargs=None): pass def shutdown(self): pass """) register_module_extender(AstroidManager(), "multiprocessing.managers", _multiprocessing_managers_transform) register_module_extender(AstroidManager(), "multiprocessing", _multiprocessing_transform)
{py3_args} {communicate_signature}: return {communicate!r} {wait_signature}: return self.returncode def poll(self): return self.returncode def send_signal(self, signal): pass def terminate(self): pass def kill(self): pass {ctx_manager} """) if PY39_PLUS: code += """ @classmethod def __class_getitem__(cls, item): pass """ init_lines = textwrap.dedent(init).splitlines() indented_init = "\n".join(" " * 4 + line for line in init_lines) code += indented_init return parse(code) register_module_extender(AstroidManager(), "subprocess", _subprocess_transform)
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """ Astroid hooks for numpy.core.einsumfunc module: https://github.com/numpy/numpy/blob/main/numpy/core/einsumfunc.py """ from astroid import nodes from astroid.brain.helpers import register_module_extender from astroid.builder import parse from astroid.manager import AstroidManager def numpy_core_einsumfunc_transform() -> nodes.Module: return parse(""" def einsum(*operands, out=None, optimize=False, **kwargs): return numpy.ndarray([0, 0]) """) register_module_extender(AstroidManager(), "numpy.core.einsumfunc", numpy_core_einsumfunc_transform)
class AstroidManagerTC(TestCase): def setUp(self): self.manager = AstroidManager() self.manager.clear_cache() # take care of borg def test_ast_from_file(self): """check if the method return a good astroid object""" import unittest filepath = unittest.__file__ astroid = self.manager.ast_from_file(filepath) self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_file_cache(self): """check if the cache works""" import unittest filepath = unittest.__file__ self.manager.ast_from_file(filepath) astroid = self.manager.ast_from_file('unhandledName', 'unittest') self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_file_astro_builder(self): """check if the source is at True, AstroidBuilder build a good astroid""" import unittest filepath = unittest.__file__ astroid = self.manager.ast_from_file(filepath, None, True, True) self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_file_name_astro_builder_exception(self): """check if an exception is thrown if we give a wrong filepath""" self.assertRaises(AstroidBuildingException, self.manager.ast_from_file, 'unhandledName') def test_do_not_expose_main(self): obj = self.manager.ast_from_module_name('__main__') self.assertEqual(obj.name, '__main__') self.assertEqual(list(obj.items()), []) def test_ast_from_module_name(self): """check if the ast_from_module_name method return a good astroid""" astroid = self.manager.ast_from_module_name('unittest') self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_module_name_not_python_source(self): """check if the ast_from_module_name method return a good astroid with a no python source module""" astroid = self.manager.ast_from_module_name('time') self.assertEqual(astroid.name, 'time') self.assertIn('time', self.manager.astroid_cache) self.assertEqual(astroid.pure_python, False) def test_ast_from_module_name_astro_builder_exception(self): """check if the method raise an exception if we give a wrong module""" self.assertRaises(AstroidBuildingException, self.manager.ast_from_module_name, 'unhandledModule') def _test_ast_from_zip(self, archive): origpath = sys.path[:] sys.modules.pop('mypypa', None) archive_path = join(DATA, archive) sys.path.insert(0, archive_path) try: module = self.manager.ast_from_module_name('mypypa') self.assertEqual(module.name, 'mypypa') end = join(archive, 'mypypa') self.assertTrue(module.file.endswith(end), "%s doesn't endswith %s" % (module.file, end)) finally: # remove the module, else after importing egg, we don't get the zip if 'mypypa' in self.manager.astroid_cache: del self.manager.astroid_cache['mypypa'] del self.manager._mod_file_cache[('mypypa', None)] if archive_path in sys.path_importer_cache: del sys.path_importer_cache[archive_path] sys.path = origpath def test_ast_from_module_name_egg(self): self._test_ast_from_zip('MyPyPa-0.1.0-py2.5.egg') def test_ast_from_module_name_zip(self): self._test_ast_from_zip('MyPyPa-0.1.0-py2.5.zip') def test_zip_import_data(self): """check if zip_import_data works""" filepath = self.datapath('MyPyPa-0.1.0-py2.5.zip/mypypa') astroid = self.manager.zip_import_data(filepath) self.assertEqual(astroid.name, 'mypypa') def test_zip_import_data_without_zipimport(self): """check if zip_import_data return None without zipimport""" self.assertEqual(self.manager.zip_import_data('path'), None) def test_file_from_module(self): """check if the unittest filepath is equals to the result of the method""" import unittest if PY3K: unittest_file = unittest.__file__ else: unittest_file = unittest.__file__[:-1] self.assertEqual(unittest_file, self.manager.file_from_module_name('unittest', None)) def test_file_from_module_name_astro_building_exception(self): """check if the method launch a exception with a wrong module name""" self.assertRaises(AstroidBuildingException, self.manager.file_from_module_name, 'unhandledModule', None) def test_ast_from_module(self): import unittest astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.pure_python, True) import time astroid = self.manager.ast_from_module(time) self.assertEqual(astroid.pure_python, False) def test_ast_from_module_cache(self): """check if the module is in the cache manager""" import unittest astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_class(self): astroid = self.manager.ast_from_class(int) self.assertEqual(astroid.name, 'int') self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object) self.assertEqual(astroid.name, 'object') self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn('__setattr__', astroid) def test_ast_from_class_with_module(self): """check if the method works with the module name""" astroid = self.manager.ast_from_class(int, int.__module__) self.assertEqual(astroid.name, 'int') self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object, object.__module__) self.assertEqual(astroid.name, 'object') self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn('__setattr__', astroid) def test_ast_from_class_attr_error(self): """give a wrong class at the ast_from_class method""" self.assertRaises(AstroidBuildingException, self.manager.ast_from_class, None) def test_from_directory(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, 'data') self.assertEqual(obj.name, 'data') self.assertEqual(obj.path, join(DATA, '__init__.py')) def test_project_node(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, 'data') expected = set(['SSL1', '__init__', 'all', 'appl', 'format', 'module', 'module2', 'noendingnewline', 'nonregr', 'notall']) expected = [ 'data', 'data.SSL1', 'data.SSL1.Connection1', 'data.absimport', 'data.all', 'data.appl', 'data.appl.myConnection', 'data.email', 'data.find_test', 'data.find_test.module', 'data.find_test.module2', 'data.find_test.noendingnewline', 'data.find_test.nonregr', 'data.format', 'data.lmfp', 'data.lmfp.foo', 'data.module', 'data.module1abs', 'data.module1abs.core', 'data.module2', 'data.noendingnewline', 'data.nonregr', 'data.notall'] self.assertListEqual(sorted(k for k in list(obj.keys())), expected)
("c_ushort", "int", "H"), ("c_wchar", "str", "u"), ) src = [ """ from _ctypes import _SimpleCData class c_bool(_SimpleCData): def __init__(self, value): self.value = True self._type_ = '?' """ ] for c_type, builtin_type, type_code in c_class_to_type: src.append(f""" class {c_type}(_SimpleCData): def __init__(self, value): self.value = {builtin_type}(value) self._type_ = '{type_code}' """) return parse("\n".join(src)) if not hasattr(sys, "pypy_version_info"): # No need of this module in pypy where everything is written in python register_module_extender(AstroidManager(), "ctypes", enrich_ctypes_redefined_types)
# Builtins inference register_builtin_transform(infer_bool, "bool") register_builtin_transform(infer_super, "super") register_builtin_transform(infer_callable, "callable") register_builtin_transform(infer_property, "property") register_builtin_transform(infer_getattr, "getattr") register_builtin_transform(infer_hasattr, "hasattr") register_builtin_transform(infer_tuple, "tuple") register_builtin_transform(infer_set, "set") register_builtin_transform(infer_list, "list") register_builtin_transform(infer_dict, "dict") register_builtin_transform(infer_frozenset, "frozenset") register_builtin_transform(infer_type, "type") register_builtin_transform(infer_slice, "slice") register_builtin_transform(infer_isinstance, "isinstance") register_builtin_transform(infer_issubclass, "issubclass") register_builtin_transform(infer_len, "len") register_builtin_transform(infer_str, "str") register_builtin_transform(infer_int, "int") register_builtin_transform(infer_dict_fromkeys, "dict.fromkeys") # Infer object.__new__ calls AstroidManager().register_transform( nodes.ClassDef, inference_tip(_infer_object__new__decorator), _infer_object__new__decorator_check, )
def _proxied(self): ast_builtins = AstroidManager().builtins_module return ast_builtins.getattr("super")[0]
def _extend_builtins(class_transforms): builtin_ast = AstroidManager().builtins_module for class_name, transform in class_transforms.items(): transform(builtin_ast[class_name])
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. """ for the visitors.diadefs module """ import sys from os.path import join, abspath, dirname from logilab.common.testlib import TestCase, unittest_main from astroid import nodes, inspector from astroid.bases import Instance, YES from astroid.manager import AstroidManager, _silent_no_wrap MANAGER = AstroidManager() def astroid_wrapper(func, modname): return func(modname) DATA2 = join(dirname(abspath(__file__)), 'data2') class LinkerTC(TestCase): def setUp(self): self.project = MANAGER.project_from_files([DATA2], astroid_wrapper) self.linker = inspector.Linker(self.project) self.linker.visit(self.project)
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Astroid hooks for unittest module""" from astroid.brain.helpers import register_module_extender from astroid.builder import parse from astroid.const import PY38_PLUS from astroid.manager import AstroidManager def IsolatedAsyncioTestCaseImport(): """ In the unittest package, the IsolatedAsyncioTestCase class is imported lazily, i.e only when the __getattr__ method of the unittest module is called with 'IsolatedAsyncioTestCase' as argument. Thus the IsolatedAsyncioTestCase is not imported statically (during import time). This function mocks a classical static import of the IsolatedAsyncioTestCase. (see https://github.com/PyCQA/pylint/issues/4060) """ return parse(""" from .async_case import IsolatedAsyncioTestCase """) if PY38_PLUS: register_module_extender(AstroidManager(), "unittest", IsolatedAsyncioTestCaseImport)
def teardown_class(cls): if cls._builtins: AstroidManager().astroid_cache["builtins"] = cls._builtins
class Python3TC(TestCase): def setUp(self): self.manager = AstroidManager() self.manager.clear_cache() # take care of borg self.builder = AstroidBuilder(self.manager) @require_version('3.0') def test_starred_notation(self): astroid = self.builder.string_build("*a, b = [1, 2, 3]", 'test', 'test') # Get the star node node = next(next(next(astroid.get_children()).get_children()).get_children()) self.assertTrue(isinstance(node.ass_type(), Assign)) @require_version('3.3') def test_yield_from(self): body = dedent(""" def func(): yield from iter([1, 2]) """) astroid = self.builder.string_build(body) func = astroid.body[0] self.assertIsInstance(func, Function) yieldfrom_stmt = func.body[0] self.assertIsInstance(yieldfrom_stmt, Discard) self.assertIsInstance(yieldfrom_stmt.value, YieldFrom) self.assertEqual(yieldfrom_stmt.as_string(), 'yield from iter([1, 2])') @require_version('3.3') def test_yield_from_is_generator(self): body = dedent(""" def func(): yield from iter([1, 2]) """) astroid = self.builder.string_build(body) func = astroid.body[0] self.assertIsInstance(func, Function) self.assertTrue(func.is_generator()) @require_version('3.3') def test_yield_from_as_string(self): body = dedent(""" def func(): yield from iter([1, 2]) value = yield from other() """) astroid = self.builder.string_build(body) func = astroid.body[0] self.assertEqual(func.as_string().strip(), body.strip()) # metaclass tests @require_version('3.0') def test_simple_metaclass(self): astroid = self.builder.string_build("class Test(metaclass=type): pass") klass = astroid.body[0] metaclass = klass.metaclass() self.assertIsInstance(metaclass, Class) self.assertEqual(metaclass.name, 'type') @require_version('3.0') def test_metaclass_error(self): astroid = self.builder.string_build("class Test(metaclass=typ): pass") klass = astroid.body[0] self.assertFalse(klass.metaclass()) @require_version('3.0') def test_metaclass_imported(self): astroid = self.builder.string_build(dedent(""" from abc import ABCMeta class Test(metaclass=ABCMeta): pass""")) klass = astroid.body[1] metaclass = klass.metaclass() self.assertIsInstance(metaclass, Class) self.assertEqual(metaclass.name, 'ABCMeta') @require_version('3.0') def test_as_string(self): body = dedent(""" from abc import ABCMeta class Test(metaclass=ABCMeta): pass""") astroid = self.builder.string_build(body) klass = astroid.body[1] self.assertEqual(klass.as_string(), '\n\nclass Test(metaclass=ABCMeta):\n pass\n') @require_version('3.0') def test_old_syntax_works(self): astroid = self.builder.string_build(dedent(""" class Test: __metaclass__ = type class SubTest(Test): pass """)) klass = astroid['SubTest'] metaclass = klass.metaclass() self.assertIsNone(metaclass) @require_version('3.0') def test_metaclass_yes_leak(self): astroid = self.builder.string_build(dedent(""" # notice `ab` instead of `abc` from ab import ABCMeta class Meta(metaclass=ABCMeta): pass """)) klass = astroid['Meta'] self.assertIsNone(klass.metaclass()) @require_version('3.0') def test_parent_metaclass(self): astroid = self.builder.string_build(dedent(""" from abc import ABCMeta class Test(metaclass=ABCMeta): pass class SubTest(Test): pass """)) klass = astroid['SubTest'] self.assertTrue(klass.newstyle) metaclass = klass.metaclass() self.assertIsInstance(metaclass, Class) self.assertEqual(metaclass.name, 'ABCMeta') @require_version('3.0') def test_metaclass_ancestors(self): astroid = self.builder.string_build(dedent(""" from abc import ABCMeta class FirstMeta(metaclass=ABCMeta): pass class SecondMeta(metaclass=type): pass class Simple: pass class FirstImpl(FirstMeta): pass class SecondImpl(FirstImpl): pass class ThirdImpl(Simple, SecondMeta): pass """)) classes = { 'ABCMeta': ('FirstImpl', 'SecondImpl'), 'type': ('ThirdImpl', ) } for metaclass, names in classes.items(): for name in names: impl = astroid[name] meta = impl.metaclass() self.assertIsInstance(meta, Class) self.assertEqual(meta.name, metaclass) @require_version('3.0') def test_annotation_support(self): astroid = self.builder.string_build(dedent(""" def test(a: int, b: str, c: None, d, e, *args: float, **kwargs: int)->int: pass """)) func = astroid['test'] self.assertIsInstance(func.args.varargannotation, Name) self.assertEqual(func.args.varargannotation.name, 'float') self.assertIsInstance(func.args.kwargannotation, Name) self.assertEqual(func.args.kwargannotation.name, 'int') self.assertIsInstance(func.returns, Name) self.assertEqual(func.returns.name, 'int') arguments = func.args self.assertIsInstance(arguments.annotations[0], Name) self.assertEqual(arguments.annotations[0].name, 'int') self.assertIsInstance(arguments.annotations[1], Name) self.assertEqual(arguments.annotations[1].name, 'str') self.assertIsInstance(arguments.annotations[2], Const) self.assertIsNone(arguments.annotations[2].value) self.assertIsNone(arguments.annotations[3]) self.assertIsNone(arguments.annotations[4]) astroid = self.builder.string_build(dedent(""" def test(a: int=1, b: str=2): pass """)) func = astroid['test'] self.assertIsInstance(func.args.annotations[0], Name) self.assertEqual(func.args.annotations[0].name, 'int') self.assertIsInstance(func.args.annotations[1], Name) self.assertEqual(func.args.annotations[1].name, 'str') self.assertIsNone(func.returns)
field_names = "" return field_names def _is_enum_subclass(cls: astroid.ClassDef) -> bool: """Return whether cls is a subclass of an Enum.""" try: return any(klass.name in ENUM_BASE_NAMES and getattr(klass.root(), "name", None) == "enum" for klass in cls.mro()) except MroError: return False AstroidManager().register_transform(nodes.Call, inference_tip(infer_named_tuple), _looks_like_namedtuple) AstroidManager().register_transform(nodes.Call, inference_tip(infer_enum), _looks_like_enum) AstroidManager().register_transform(nodes.ClassDef, infer_enum_class, predicate=_is_enum_subclass) AstroidManager().register_transform( nodes.ClassDef, inference_tip(infer_typing_namedtuple_class), _has_namedtuple_base) AstroidManager().register_transform( nodes.FunctionDef, inference_tip(infer_typing_namedtuple_function), lambda node: node.name == "NamedTuple" and getattr(node.root(), "name", None) == "typing", )
def setUp(self): self.manager = AstroidManager() self.manager.clear_cache() # take care of borg self.builder = AstroidBuilder(self.manager)
BufferedWriter = "BufferedWriter" def _generic_io_transform(node, name, cls): """Transform the given name, by adding the given *class* as a member of the node.""" io_module = AstroidManager().ast_from_module_name("_io") attribute_object = io_module[cls] instance = attribute_object.instantiate_class() node.locals[name] = [instance] def _transform_text_io_wrapper(node): # This is not always correct, since it can vary with the type of the descriptor, # being stdout, stderr or stdin. But we cannot get access to the name of the # stream, which is why we are using the BufferedWriter class as a default # value return _generic_io_transform(node, name="buffer", cls=BufferedWriter) def _transform_buffered(node): return _generic_io_transform(node, name="raw", cls=FileIO) AstroidManager().register_transform( ClassDef, _transform_buffered, lambda node: node.name in BUFFERED ) AstroidManager().register_transform( ClassDef, _transform_text_io_wrapper, lambda node: node.name == TextIOWrapper )
class PylintUCRBuilder(ConfigurationMixIn,IdGeneratorMixIn): options = OPTIONS _out_file = None def __init__(self, args,out_file='test.xml'): ConfigurationMixIn.__init__(self, usage=__doc__) IdGeneratorMixIn.__init__(self) insert_default_options() self.manager = AstroidManager() self.register_options_provider(self.manager) args = self.load_command_line_configuration() self._out_file = out_file self.run(args) pass def run(self, args): project = self.manager.project_from_files(args) linker = Linker(project, tag=True) handler = DiadefsHandler(self.config) diadefs = handler.get_diadefs(project, linker) root = etree.Element("Classes") classes = None for diagram in diadefs: if diagram.TYPE == 'class': classes = diagram class_map = {} class_nodes = [] for c in classes.objects: ''' First pass - id generation ''' c_id = str(self.generate_id()) node = etree.Element("Class",name=c.title,id=c_id,label=c.node.root().name) if class_map.has_key(c.title): print "Duplicate class name - ",c.title else: class_map[c.title] = c_id root.append(node) class_nodes.append((c,node)) attr_num = 0 typed_attrs = 0 for c, node in class_nodes: ''' Second pass - linking ''' attr_num += len(c.attrs) for a in c.attrs: a_data = [w.strip() for w in a.split(':')] found_attr = False attr_node = etree.Element('Attr',name=a_data[0]) if (len(a_data) > 1): types = [w.strip() for w in a_data[1].split(',')] for t in types: if class_map.has_key(t): print "InnerType!" found_attr = True type_node = etree.Element('CommonType', id=class_map[a_data[1]],name=a_data[1]) attr_node.append(type_node) if found_attr: typed_attrs += 1 node.append(attr_node) #mapper[obj] = node print "Numbers of all attributes in project: ", attr_num print "Numbers of typed attributes in project: ", typed_attrs print "Percentage: ", typed_attrs*1.0/attr_num print "Writing ", self._out_file f = open(self._out_file,'w') f.write(etree.tostring(root, pretty_print=True, encoding='utf-8', xml_declaration=True)) f.close()
class AstroidManagerTest(resources.SysPathSetup, resources.AstroidCacheSetupMixin, unittest.TestCase): @property def project(self): return self.manager.project_from_files( [resources.find('data')], _silent_no_wrap, 'data', black_list=['joined_strings.py']) def setUp(self): super(AstroidManagerTest, self).setUp() self.manager = AstroidManager() self.manager.clear_cache(self._builtins) # take care of borg def test_ast_from_file(self): """check if the method return a good astroid object""" import unittest filepath = unittest.__file__ astroid = self.manager.ast_from_file(filepath) self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_file_cache(self): """check if the cache works""" import unittest filepath = unittest.__file__ self.manager.ast_from_file(filepath) astroid = self.manager.ast_from_file('unhandledName', 'unittest') self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_file_astro_builder(self): """check if the source is at True, AstroidBuilder build a good astroid""" import unittest filepath = unittest.__file__ astroid = self.manager.ast_from_file(filepath, None, True, True) self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_file_name_astro_builder_exception(self): """check if an exception is thrown if we give a wrong filepath""" self.assertRaises(AstroidBuildingException, self.manager.ast_from_file, 'unhandledName') def test_do_not_expose_main(self): obj = self.manager.ast_from_module_name('__main__') self.assertEqual(obj.name, '__main__') self.assertEqual(obj.items(), []) def test_ast_from_module_name(self): """check if the ast_from_module_name method return a good astroid""" astroid = self.manager.ast_from_module_name('unittest') self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_module_name_not_python_source(self): """check if the ast_from_module_name method return a good astroid with a no python source module""" astroid = self.manager.ast_from_module_name('time') self.assertEqual(astroid.name, 'time') self.assertIn('time', self.manager.astroid_cache) self.assertEqual(astroid.pure_python, False) def test_ast_from_module_name_astro_builder_exception(self): """check if the method raise an exception if we give a wrong module""" self.assertRaises(AstroidBuildingException, self.manager.ast_from_module_name, 'unhandledModule') def _test_ast_from_zip(self, archive): origpath = sys.path[:] sys.modules.pop('mypypa', None) archive_path = resources.find(archive) sys.path.insert(0, archive_path) try: module = self.manager.ast_from_module_name('mypypa') self.assertEqual(module.name, 'mypypa') end = os.path.join(archive, 'mypypa') self.assertTrue(module.file.endswith(end), "%s doesn't endswith %s" % (module.file, end)) finally: # remove the module, else after importing egg, we don't get the zip if 'mypypa' in self.manager.astroid_cache: del self.manager.astroid_cache['mypypa'] del self.manager._mod_file_cache[('mypypa', None)] if archive_path in sys.path_importer_cache: del sys.path_importer_cache[archive_path] sys.path = origpath def test_ast_from_module_name_egg(self): self._test_ast_from_zip( os.path.sep.join(['data', os.path.normcase('MyPyPa-0.1.0-py2.5.egg')]) ) def test_ast_from_module_name_zip(self): self._test_ast_from_zip( os.path.sep.join(['data', os.path.normcase('MyPyPa-0.1.0-py2.5.zip')]) ) def test_zip_import_data(self): """check if zip_import_data works""" filepath = resources.find('data/MyPyPa-0.1.0-py2.5.zip/mypypa') astroid = self.manager.zip_import_data(filepath) self.assertEqual(astroid.name, 'mypypa') def test_zip_import_data_without_zipimport(self): """check if zip_import_data return None without zipimport""" self.assertEqual(self.manager.zip_import_data('path'), None) def test_file_from_module(self): """check if the unittest filepath is equals to the result of the method""" if sys.version_info > (3, 0): unittest_file = unittest.__file__ else: unittest_file = unittest.__file__[:-1] self.assertEqual(unittest_file, self.manager.file_from_module_name('unittest', None)[0]) def test_file_from_module_name_astro_building_exception(self): """check if the method launch a exception with a wrong module name""" self.assertRaises(AstroidBuildingException, self.manager.file_from_module_name, 'unhandledModule', None) def test_ast_from_module(self): astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.pure_python, True) import time astroid = self.manager.ast_from_module(time) self.assertEqual(astroid.pure_python, False) def test_ast_from_module_cache(self): """check if the module is in the cache manager""" astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.name, 'unittest') self.assertIn('unittest', self.manager.astroid_cache) def test_ast_from_class(self): astroid = self.manager.ast_from_class(int) self.assertEqual(astroid.name, 'int') self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object) self.assertEqual(astroid.name, 'object') self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn('__setattr__', astroid) def test_ast_from_class_with_module(self): """check if the method works with the module name""" astroid = self.manager.ast_from_class(int, int.__module__) self.assertEqual(astroid.name, 'int') self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object, object.__module__) self.assertEqual(astroid.name, 'object') self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn('__setattr__', astroid) def test_ast_from_class_attr_error(self): """give a wrong class at the ast_from_class method""" self.assertRaises(AstroidBuildingException, self.manager.ast_from_class, None) def test_from_directory(self): self.assertEqual(self.project.name, 'data') self.assertEqual(self.project.path, os.path.abspath(resources.find('data/__init__.py'))) def test_project_node(self): expected = [ 'data', 'data.SSL1', 'data.SSL1.Connection1', 'data.absimp', 'data.absimp.sidepackage', 'data.absimp.string', 'data.absimport', 'data.all', 'data.appl', 'data.appl.myConnection', 'data.clientmodule_test', 'data.descriptor_crash', 'data.email', 'data.find_test', 'data.find_test.module', 'data.find_test.module2', 'data.find_test.noendingnewline', 'data.find_test.nonregr', 'data.format', 'data.lmfp', 'data.lmfp.foo', 'data.module', 'data.module1abs', 'data.module1abs.core', 'data.module2', 'data.noendingnewline', 'data.nonregr', 'data.notall', 'data.package', 'data.package.absimport', 'data.package.hello', 'data.package.import_package_subpackage_module', 'data.package.subpackage', 'data.package.subpackage.module', 'data.recursion', 'data.suppliermodule_test', 'data.unicode_package', 'data.unicode_package.core'] self.assertListEqual(sorted(self.project.keys()), expected) def testFailedImportHooks(self): def hook(modname): if modname == 'foo.bar': return unittest else: raise AstroidBuildingException() with self.assertRaises(AstroidBuildingException): self.manager.ast_from_module_name('foo.bar') self.manager.register_failed_import_hook(hook) self.assertEqual(unittest, self.manager.ast_from_module_name('foo.bar')) with self.assertRaises(AstroidBuildingException): self.manager.ast_from_module_name('foo.bar.baz') del self.manager._failed_import_hooks[0]
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Hooks for nose library.""" import re import textwrap import astroid.builder from astroid.brain.helpers import register_module_extender from astroid.exceptions import InferenceError from astroid.manager import AstroidManager _BUILDER = astroid.builder.AstroidBuilder(AstroidManager()) CAPITALS = re.compile("([A-Z])") def _pep8(name, caps=CAPITALS): return caps.sub(lambda m: "_" + m.groups()[0].lower(), name) def _nose_tools_functions(): """Get an iterator of names and bound methods.""" module = _BUILDER.string_build( textwrap.dedent(""" import unittest class Test(unittest.TestCase): pass a = Test()
def setUp(self): self.manager = AstroidManager() self.manager.astroid_cache.clear()
class AstroidManagerTC(TestCase): def setUp(self): self.manager = AstroidManager() self.manager.astroid_cache.clear() def test_ast_from_module(self): import unittest astroid = self.manager.ast_from_module(unittest) self.assertEqual(astroid.pure_python, True) import time astroid = self.manager.ast_from_module(time) self.assertEqual(astroid.pure_python, False) def test_ast_from_class(self): astroid = self.manager.ast_from_class(int) self.assertEqual(astroid.name, 'int') self.assertEqual(astroid.parent.frame().name, BUILTINS) astroid = self.manager.ast_from_class(object) self.assertEqual(astroid.name, 'object') self.assertEqual(astroid.parent.frame().name, BUILTINS) self.assertIn('__setattr__', astroid) def _test_ast_from_zip(self, archive): origpath = sys.path[:] sys.modules.pop('mypypa', None) archive_path = join(DATA, archive) sys.path.insert(0, archive_path) try: module = self.manager.ast_from_module_name('mypypa') self.assertEqual(module.name, 'mypypa') self.assertTrue(module.file.endswith('%s/mypypa' % archive), module.file) finally: # remove the module, else after importing egg, we don't get the zip if 'mypypa' in self.manager.astroid_cache: del self.manager.astroid_cache['mypypa'] del self.manager._mod_file_cache[('mypypa', None)] if archive_path in sys.path_importer_cache: del sys.path_importer_cache[archive_path] sys.path = origpath def test_ast_from_module_name_egg(self): self._test_ast_from_zip('MyPyPa-0.1.0-py2.5.egg') def test_ast_from_module_name_zip(self): self._test_ast_from_zip('MyPyPa-0.1.0-py2.5.zip') def test_from_directory(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, 'data') self.assertEqual(obj.name, 'data') self.assertEqual(obj.path, join(DATA, '__init__.py')) def test_project_node(self): obj = self.manager.project_from_files([DATA], _silent_no_wrap, 'data') expected = set([ 'SSL1', '__init__', 'all', 'appl', 'format', 'module', 'module2', 'noendingnewline', 'nonregr', 'notall' ]) expected = [ 'data', 'data.SSL1', 'data.SSL1.Connection1', 'data.absimport', 'data.all', 'data.appl', 'data.appl.myConnection', 'data.email', 'data.format', 'data.module', 'data.module2', 'data.noendingnewline', 'data.nonregr', 'data.notall' ] self.assertListEqual(sorted(k for k in obj.keys()), expected) def test_do_not_expose_main(self): obj = self.manager.ast_from_module_name('__main__') self.assertEqual(obj.name, '__main__') self.assertEqual(obj.items(), [])
def setUp(self): super(AstroidManagerTest, self).setUp() self.manager = AstroidManager() self.manager.clear_cache(self._builtins) # take care of borg
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from astroid.brain.helpers import register_module_extender from astroid.builder import parse from astroid.manager import AstroidManager def _re_transform(): return parse(""" from collections import namedtuple _Method = namedtuple('_Method', 'name ident salt_chars total_size') METHOD_SHA512 = _Method('SHA512', '6', 16, 106) METHOD_SHA256 = _Method('SHA256', '5', 16, 63) METHOD_BLOWFISH = _Method('BLOWFISH', 2, 'b', 22) METHOD_MD5 = _Method('MD5', '1', 8, 34) METHOD_CRYPT = _Method('CRYPT', None, 2, 13) """) register_module_extender(AstroidManager(), "crypt", _re_transform)
def setUp(self): self.manager = AstroidManager() self.builder = AstroidBuilder(self.manager) self.manager.astroid_cache.clear()
class Python3TC(unittest.TestCase): def setUp(self): self.manager = AstroidManager() self.manager.clear_cache() # take care of borg self.builder = AstroidBuilder(self.manager) @require_version('3.0') def test_starred_notation(self): astroid = self.builder.string_build("*a, b = [1, 2, 3]", 'test', 'test') # Get the star node node = next(next(next(astroid.get_children()).get_children()).get_children()) self.assertTrue(isinstance(node.ass_type(), Assign)) @require_version('3.3') def test_yield_from(self): body = dedent(""" def func(): yield from iter([1, 2]) """) astroid = self.builder.string_build(body) func = astroid.body[0] self.assertIsInstance(func, Function) yieldfrom_stmt = func.body[0] self.assertIsInstance(yieldfrom_stmt, Discard) self.assertIsInstance(yieldfrom_stmt.value, YieldFrom) self.assertEqual(yieldfrom_stmt.as_string(), 'yield from iter([1, 2])') @require_version('3.3') def test_yield_from_is_generator(self): body = dedent(""" def func(): yield from iter([1, 2]) """) astroid = self.builder.string_build(body) func = astroid.body[0] self.assertIsInstance(func, Function) self.assertTrue(func.is_generator()) @require_version('3.3') def test_yield_from_as_string(self): body = dedent(""" def func(): yield from iter([1, 2]) value = yield from other() """) astroid = self.builder.string_build(body) func = astroid.body[0] self.assertEqual(func.as_string().strip(), body.strip()) # metaclass tests @require_version('3.0') def test_simple_metaclass(self): astroid = self.builder.string_build("class Test(metaclass=type): pass") klass = astroid.body[0] metaclass = klass.metaclass() self.assertIsInstance(metaclass, Class) self.assertEqual(metaclass.name, 'type') @require_version('3.0') def test_metaclass_error(self): astroid = self.builder.string_build("class Test(metaclass=typ): pass") klass = astroid.body[0] self.assertFalse(klass.metaclass()) @require_version('3.0') def test_metaclass_imported(self): astroid = self.builder.string_build(dedent(""" from abc import ABCMeta class Test(metaclass=ABCMeta): pass""")) klass = astroid.body[1] metaclass = klass.metaclass() self.assertIsInstance(metaclass, Class) self.assertEqual(metaclass.name, 'ABCMeta') @require_version('3.0') def test_as_string(self): body = dedent(""" from abc import ABCMeta class Test(metaclass=ABCMeta): pass""") astroid = self.builder.string_build(body) klass = astroid.body[1] self.assertEqual(klass.as_string(), '\n\nclass Test(metaclass=ABCMeta):\n pass\n') @require_version('3.0') def test_old_syntax_works(self): astroid = self.builder.string_build(dedent(""" class Test: __metaclass__ = type class SubTest(Test): pass """)) klass = astroid['SubTest'] metaclass = klass.metaclass() self.assertIsNone(metaclass) @require_version('3.0') def test_metaclass_yes_leak(self): astroid = self.builder.string_build(dedent(""" # notice `ab` instead of `abc` from ab import ABCMeta class Meta(metaclass=ABCMeta): pass """)) klass = astroid['Meta'] self.assertIsNone(klass.metaclass()) @require_version('3.0') def test_parent_metaclass(self): astroid = self.builder.string_build(dedent(""" from abc import ABCMeta class Test(metaclass=ABCMeta): pass class SubTest(Test): pass """)) klass = astroid['SubTest'] self.assertTrue(klass.newstyle) metaclass = klass.metaclass() self.assertIsInstance(metaclass, Class) self.assertEqual(metaclass.name, 'ABCMeta') @require_version('3.0') def test_metaclass_ancestors(self): astroid = self.builder.string_build(dedent(""" from abc import ABCMeta class FirstMeta(metaclass=ABCMeta): pass class SecondMeta(metaclass=type): pass class Simple: pass class FirstImpl(FirstMeta): pass class SecondImpl(FirstImpl): pass class ThirdImpl(Simple, SecondMeta): pass """)) classes = { 'ABCMeta': ('FirstImpl', 'SecondImpl'), 'type': ('ThirdImpl', ) } for metaclass, names in classes.items(): for name in names: impl = astroid[name] meta = impl.metaclass() self.assertIsInstance(meta, Class) self.assertEqual(meta.name, metaclass) @require_version('3.0') def test_annotation_support(self): astroid = self.builder.string_build(dedent(""" def test(a: int, b: str, c: None, d, e, *args: float, **kwargs: int)->int: pass """)) func = astroid['test'] self.assertIsInstance(func.args.varargannotation, Name) self.assertEqual(func.args.varargannotation.name, 'float') self.assertIsInstance(func.args.kwargannotation, Name) self.assertEqual(func.args.kwargannotation.name, 'int') self.assertIsInstance(func.returns, Name) self.assertEqual(func.returns.name, 'int') arguments = func.args self.assertIsInstance(arguments.annotations[0], Name) self.assertEqual(arguments.annotations[0].name, 'int') self.assertIsInstance(arguments.annotations[1], Name) self.assertEqual(arguments.annotations[1].name, 'str') self.assertIsInstance(arguments.annotations[2], Const) self.assertIsNone(arguments.annotations[2].value) self.assertIsNone(arguments.annotations[3]) self.assertIsNone(arguments.annotations[4]) astroid = self.builder.string_build(dedent(""" def test(a: int=1, b: str=2): pass """)) func = astroid['test'] self.assertIsInstance(func.args.annotations[0], Name) self.assertEqual(func.args.annotations[0].name, 'int') self.assertIsInstance(func.args.annotations[1], Name) self.assertEqual(func.args.annotations[1].name, 'str') self.assertIsNone(func.returns)
from astroid.inference_tip import inference_tip from astroid.manager import AstroidManager from astroid.nodes.node_classes import Attribute def numpy_core_numeric_transform(): return parse(""" # different functions defined in numeric.py import numpy def zeros_like(a, dtype=None, order='K', subok=True, shape=None): return numpy.ndarray((0, 0)) def ones_like(a, dtype=None, order='K', subok=True, shape=None): return numpy.ndarray((0, 0)) def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None): return numpy.ndarray((0, 0)) """) register_module_extender(AstroidManager(), "numpy.core.numeric", numpy_core_numeric_transform) METHODS_TO_BE_INFERRED = { "ones": """def ones(shape, dtype=None, order='C'): return numpy.ndarray([0, 0])""" } for method_name, function_src in METHODS_TO_BE_INFERRED.items(): inference_function = functools.partial(infer_numpy_member, function_src) AstroidManager().register_transform( Attribute, inference_tip(inference_function), functools.partial(looks_like_numpy_member, method_name), )