def leave_module(self, node): """leave module: check globals """ assert len(self._to_consume) == 1 not_consumed = self._to_consume.pop()[0] # attempt to check for __all__ if defined if '__all__' in node.locals: assigned = next(node.igetattr('__all__')) if assigned is not astroid.YES: for elt in getattr(assigned, 'elts', ()): try: elt_name = next(elt.infer()) except astroid.InferenceError: continue if not isinstance(elt_name, astroid.Const) \ or not isinstance(elt_name.value, six.string_types): self.add_message('invalid-all-object', args=elt.as_string(), node=elt) continue elt_name = elt_name.value # If elt is in not_consumed, remove it from not_consumed if elt_name in not_consumed: del not_consumed[elt_name] continue if elt_name not in node.locals: if not node.package: self.add_message('undefined-all-variable', args=elt_name, node=elt) else: basename = os.path.splitext(node.file)[0] if os.path.basename(basename) == '__init__': name = node.name + "." + elt_name try: modutils.file_from_modpath(name.split(".")) except ImportError: self.add_message('undefined-all-variable', args=elt_name, node=elt) except SyntaxError: # don't yield an syntax-error warning, # because it will be later yielded # when the file will be checked pass # don't check unused imports in __init__ files if not self.config.init_import and node.package: return self._check_imports(not_consumed)
def test_std_lib(self): from os import path self.assertEqual( os.path.realpath( modutils.file_from_modpath(['os', 'path']).replace('.pyc', '.py')), os.path.realpath(path.__file__.replace('.pyc', '.py')))
def project_from_files( files, func_wrapper=_astroid_wrapper, project_name="no name", black_list=("CVS",) ): """return a Project from a list of files or modules""" # build the project representation astroid_manager = manager.AstroidManager() project = Project(project_name) for something in files: if not os.path.exists(something): fpath = modutils.file_from_modpath(something.split(".")) elif os.path.isdir(something): fpath = os.path.join(something, "__init__.py") else: fpath = something ast = func_wrapper(astroid_manager.ast_from_file, fpath) if ast is None: continue project.path = project.path or ast.file project.add_module(ast) base_name = ast.name # recurse in package except if __init__ was explicitly given if ast.package and something.find("__init__") == -1: # recurse on others packages / modules if this is a package for fpath in modutils.get_module_files( os.path.dirname(ast.file), black_list ): ast = func_wrapper(astroid_manager.ast_from_file, fpath) if ast is None or ast.name == base_name: continue project.add_module(ast) return project
def project_from_files(self, files, func_wrapper=astroid_wrapper, project_name=None, black_list=None): """return a Project from a list of files or modules""" # build the project representation project_name = project_name or self.config.project black_list = black_list or self.config.black_list project = Project(project_name) for something in files: if not exists(something): fpath = modutils.file_from_modpath(something.split('.')) elif isdir(something): fpath = join(something, '__init__.py') else: fpath = something astroid = func_wrapper(self.ast_from_file, fpath) if astroid is None: continue # XXX why is first file defining the project.path ? project.path = project.path or astroid.file project.add_module(astroid) base_name = astroid.name # recurse in package except if __init__ was explicitly given if astroid.package and something.find('__init__') == -1: # recurse on others packages / modules if this is a package for fpath in modutils.get_module_files(dirname(astroid.file), black_list): astroid = func_wrapper(self.ast_from_file, fpath) if astroid is None or astroid.name == base_name: continue project.add_module(astroid) return project
def project_from_files(self, files, func_wrapper=astroid_wrapper, project_name=None, black_list=None): """return a Project from a list of files or modules""" # build the project representation project_name = project_name or self.config.project black_list = black_list or self.config.black_list project = Project(project_name) for something in files: if not exists(something): fpath = file_from_modpath(something.split('.')) elif isdir(something): fpath = join(something, '__init__.py') else: fpath = something astroid = func_wrapper(self.ast_from_file, fpath) if astroid is None: continue # XXX why is first file defining the project.path ? project.path = project.path or astroid.file project.add_module(astroid) base_name = astroid.name # recurse in package except if __init__ was explicitly given if astroid.package and something.find('__init__') == -1: # recurse on others packages / modules if this is a package for fpath in get_module_files(dirname(astroid.file), black_list): astroid = func_wrapper(self.ast_from_file, fpath) if astroid is None or astroid.name == base_name: continue project.add_module(astroid) return project
def test_std_lib(self): path = modutils.file_from_modpath(["os", "path"]).replace(".pyc", ".py") self.assertEqual( os.path.realpath(path), os.path.realpath(os.path.__file__.replace(".pyc", ".py")), )
def project_from_files(files, func_wrapper=_astroid_wrapper, project_name="no name", black_list=('CVS',)): """return a Project from a list of files or modules""" # build the project representation astroid_manager = manager.AstroidManager() project = Project(project_name) for something in files: if not os.path.exists(something): fpath = modutils.file_from_modpath(something.split('.')) elif os.path.isdir(something): fpath = os.path.join(something, '__init__.py') else: fpath = something ast = func_wrapper(astroid_manager.ast_from_file, fpath) if ast is None: continue # XXX why is first file defining the project.path ? project.path = project.path or ast.file project.add_module(ast) base_name = ast.name # recurse in package except if __init__ was explicitly given if ast.package and something.find('__init__') == -1: # recurse on others packages / modules if this is a package for fpath in modutils.get_module_files(os.path.dirname(ast.file), black_list): ast = func_wrapper(astroid_manager.ast_from_file, fpath) if ast is None or ast.name == base_name: continue project.add_module(ast) return project
def test_xmlplus(self): try: # don't fail if pyxml isn't installed from xml.dom import ext except ImportError: pass else: self.assertEqual(path.realpath(modutils.file_from_modpath(['xml', 'dom', 'ext']).replace('.pyc', '.py')), path.realpath(ext.__file__.replace('.pyc', '.py')))
def load_module(self): if os.path.isdir(self.file): fpath = os.path.join(self.file, "__init__.py") elif os.path.exists(self.file): fpath = self.file else: fpath = modutils.file_from_modpath(self.file.split(".")) return self._manager.ast_from_file(fpath)
def expand_modules(files_or_modules, black_list): """take a list of files/modules/packages and return the list of tuple (file, module name) which have to be actually checked """ result = [] errors = [] for something in files_or_modules: if exists(something): # this is a file or a directory try: modname = '.'.join(modpath_from_file(something)) except ImportError: modname = splitext(basename(something))[0] if isdir(something): filepath = join(something, '__init__.py') else: filepath = something else: # suppose it's a module or package modname = something try: filepath = file_from_modpath(modname.split('.')) if filepath is None: errors.append({ 'key': 'ignored-builtin-module', 'mod': modname }) continue except (ImportError, SyntaxError) as ex: # FIXME p3k : the SyntaxError is a Python bug and should be # removed as soon as possible http://bugs.python.org/issue10588 errors.append({'key': 'fatal', 'mod': modname, 'ex': ex}) continue filepath = normpath(filepath) result.append({ 'path': filepath, 'name': modname, 'isarg': True, 'basepath': filepath, 'basename': modname }) if not (modname.endswith('.__init__') or modname == '__init__') \ and '__init__.py' in filepath: for subfilepath in get_module_files(dirname(filepath), black_list): if filepath == subfilepath: continue submodname = '.'.join(modpath_from_file(subfilepath)) result.append({ 'path': subfilepath, 'name': submodname, 'isarg': False, 'basepath': filepath, 'basename': modname }) return result, errors
def file_from_module_name(self, modname, contextfile): try: value = self._mod_file_cache[(modname, contextfile)] except KeyError: try: value = file_from_modpath(modname.split('.'), context_file=contextfile) except ImportError, ex: msg = 'Unable to load module %s (%s)' % (modname, ex) value = AstroidBuildingException(msg) self._mod_file_cache[(modname, contextfile)] = value
def test_xmlplus(self): try: # don't fail if pyxml isn't installed from xml.dom import ext except ImportError: pass else: self.assertEqual( os.path.realpath( modutils.file_from_modpath(['xml', 'dom', 'ext']).replace('.pyc', '.py')), os.path.realpath(ext.__file__.replace('.pyc', '.py')))
def is_standard_module(linter, modname, std_path=None): standard = linter._old_is_standard_module(modname, std_path=std_path) if standard: try: filename = modutils.file_from_modpath([modname]) except ImportError: # Import failed, so we can suppose that the module is not standard. return False if filename is not None and '/site-packages/' in filename: return False return standard
def _check_imports_order(self, node): """Checks imports of module `node` are grouped by category Imports must follow this order: standard, 3rd party, local """ extern_imports = [] local_imports = [] std_imports = [] stdlib_paths = [sys.prefix, self.ext_lib_dir] real_prefix = getattr(sys, "real_prefix", None) if real_prefix is not None: stdlib_paths.append(real_prefix) for node, modname in self._imports_stack: package = modname.split(".")[0] if is_standard_module(modname): std_imports.append((node, package)) wrong_import = extern_imports or local_imports if not wrong_import: continue self.add_message( "wrong-import-order", node=node, args=('standard import "%s"' % node.as_string(), '"%s"' % wrong_import[0][0].as_string()), ) else: try: filename = file_from_modpath([package]) except ImportError: extern_imports.append((node, package)) continue if not filename: extern_imports.append((node, package)) continue filename = os.path.normcase(os.path.abspath(filename)) if not any(filename.startswith(path) for path in stdlib_paths): local_imports.append((node, package)) continue extern_imports.append((node, package)) if not local_imports: continue self.add_message( "wrong-import-order", node=node, args=('external import "%s"' % node.as_string(), '"%s"' % local_imports[0][0].as_string()), ) return std_imports, extern_imports, local_imports
def _check_imports_order(self, node): """Checks imports of module `node` are grouped by category Imports must follow this order: standard, 3rd party, local """ extern_imports = [] local_imports = [] std_imports = [] stdlib_paths = [sys.prefix, self.ext_lib_dir] real_prefix = getattr(sys, 'real_prefix', None) if real_prefix is not None: stdlib_paths.append(real_prefix) for node, modname in self._imports_stack: package = modname.split('.')[0] if is_standard_module(modname): std_imports.append((node, package)) wrong_import = extern_imports or local_imports if not wrong_import: continue self.add_message( 'wrong-import-order', node=node, args=('standard import "%s"' % node.as_string(), '"%s"' % wrong_import[0][0].as_string())) else: try: filename = file_from_modpath([package]) except ImportError: extern_imports.append((node, package)) continue if not filename: extern_imports.append((node, package)) continue filename = os.path.normcase(os.path.abspath(filename)) if not any(filename.startswith(path) for path in stdlib_paths): local_imports.append((node, package)) continue extern_imports.append((node, package)) if not local_imports: continue self.add_message( 'wrong-import-order', node=node, args=('external import "%s"' % node.as_string(), '"%s"' % local_imports[0][0].as_string())) return std_imports, extern_imports, local_imports
def expand_modules(files_or_modules, black_list, black_list_re): """take a list of files/modules/packages and return the list of tuple (file, module name) which have to be actually checked """ result = [] errors = [] for something in files_or_modules: if exists(something): # this is a file or a directory try: modname = '.'.join(modpath_from_file(something)) except ImportError: modname = splitext(basename(something))[0] if isdir(something): filepath = join(something, '__init__.py') else: filepath = something else: # suppose it's a module or package modname = something try: filepath = file_from_modpath(modname.split('.')) if filepath is None: continue except (ImportError, SyntaxError) as ex: # FIXME p3k : the SyntaxError is a Python bug and should be # removed as soon as possible http://bugs.python.org/issue10588 errors.append({'key': 'fatal', 'mod': modname, 'ex': ex}) continue filepath = normpath(filepath) result.append({'path': filepath, 'name': modname, 'isarg': True, 'basepath': filepath, 'basename': modname}) if not (modname.endswith('.__init__') or modname == '__init__') \ and '__init__.py' in filepath: for subfilepath in get_module_files(dirname(filepath), black_list): if filepath == subfilepath: continue if _basename_in_blacklist_re(basename(subfilepath), black_list_re): continue submodname = '.'.join(modpath_from_file(subfilepath)) result.append({'path': subfilepath, 'name': submodname, 'isarg': False, 'basepath': filepath, 'basename': modname}) return result, errors
def _get_valid_files_to_check(reporter, module_name): """A generator for all valid files to check. Uses a reporter to output messages when an input cannot be checked. """ # Allow call to check with empty args if module_name == '': m = sys.modules['__main__'] spec = importlib.util.spec_from_file_location(m.__name__, m.__file__) module_name = [spec.origin] # Enforce API to expect 1 file or directory if type is list elif isinstance(module_name, str): module_name = [module_name] # Otherwise, enforce API to expect `module_name` type as list elif not isinstance(module_name, list): print( 'No checks run. Input to check, `{}`, has invalid type, must be a list of strings.' .format(module_name)) return # Filter valid files to check for item in module_name: if not isinstance(item, str): # Issue errors for invalid types print(reporter.filename_to_display(item)) print( 'No check run on file `{}`, with invalid type. Must be type: str.\n' .format(item)) elif os.path.isdir(item): yield item elif not os.path.exists(os.path.expanduser(item)): try: # For files with dot notation, e.g., `examples.<filename>` filepath = modutils.file_from_modpath(item.split('.')) if os.path.exists(filepath): yield filepath else: print(reporter.filename_to_display(item)) print( 'Could not find the file called, `{}`\n'.format(item)) except ImportError: print(reporter.filename_to_display(item)) print('Could not find the file called, `{}`\n'.format(item)) else: yield item # Check other valid files.
def _check_imports_order(self, node): """Checks imports of module `node` are grouped by category Imports must follow this order: standard, 3rd party, local """ extern_imports = [] local_imports = [] std_imports = [] for node, modname in self._imports_stack: package = modname.split('.')[0] if is_standard_module(modname): std_imports.append((node, package)) wrong_import = extern_imports or local_imports if not wrong_import: continue if self._is_fallback_import(node, wrong_import): continue self.add_message('wrong-import-order', node=node, args=('standard import "%s"' % node.as_string(), '"%s"' % wrong_import[0][0].as_string())) else: try: filename = file_from_modpath([package]) except ImportError: continue if not filename: continue filename = os.path.normcase(os.path.abspath(filename)) if not any(filename.startswith(path) for path in self._site_packages): local_imports.append((node, package)) continue extern_imports.append((node, package)) if not local_imports: continue self.add_message('wrong-import-order', node=node, args=('external import "%s"' % node.as_string(), '"%s"' % local_imports[0][0].as_string())) return std_imports, extern_imports, local_imports
def _get_valid_files_to_check(reporter, module_name): """A generator for all valid files to check. Uses a reporter to output messages when an input cannot be checked. """ # Allow call to check with empty args if module_name == '': m = sys.modules['__main__'] spec = importlib.util.spec_from_file_location(m.__name__, m.__file__) module_name = [spec.origin] # Enforce API to expect 1 file or directory if type is list elif isinstance(module_name, str): module_name = [module_name] # Otherwise, enforce API to expect `module_name` type as list elif not isinstance(module_name, list): print('No checks run. Input to check, `{}`, has invalid type, must be a list of strings.'.format(module_name)) return # Filter valid files to check for item in module_name: if not isinstance(item, str): # Issue errors for invalid types print(reporter.filename_to_display(item)) print('No check run on file `{}`, with invalid type. Must be type: str.\n'.format(item)) elif os.path.isdir(item): yield item elif not os.path.exists(os.path.expanduser(item)): try: # For files with dot notation, e.g., `examples.<filename>` filepath = modutils.file_from_modpath(item.split('.')) if os.path.exists(filepath): yield filepath else: print(reporter.filename_to_display(item)) print('Could not find the file called, `{}`\n'.format(item)) except ImportError: print(reporter.filename_to_display(item)) print('Could not find the file called, `{}`\n'.format(item)) else: yield item # Check other valid files.
def test_site_packages(self): self.assertEqual(path.realpath(modutils.file_from_modpath(['astroid', 'modutils'])), path.realpath(modutils.__file__.replace('.pyc', '.py')))
def test_builtin(self): self.assertIsNone(modutils.file_from_modpath(['sys']))
def test_unicode_in_package_init(self): # file_from_modpath should not crash when reading an __init__ # file with unicode characters. modutils.file_from_modpath(["data", "unicode_package", "core"])
def test_site_packages(self): filename = _get_file_from_object(modutils) result = modutils.file_from_modpath(['astroid', 'modutils']) self.assertEqual(os.path.realpath(result), os.path.realpath(filename))
def test_std_lib(self): path = modutils.file_from_modpath(['os', 'path']).replace('.pyc', '.py') self.assertEqual(os.path.realpath(path), os.path.realpath(os.path.__file__.replace('.pyc', '.py')))
def test_builtin(self): self.assertEqual(modutils.file_from_modpath(['sys']), None)
def expand_modules(files_or_modules, black_list, black_list_re): """take a list of files/modules/packages and return the list of tuple (file, module name) which have to be actually checked """ result = [] errors = [] path = sys.path.copy() for something in files_or_modules: if os.path.basename(something) in black_list: continue if _basename_in_blacklist_re(os.path.basename(something), black_list_re): continue module_path = get_python_path(something) additional_search_path = [".", module_path] + path if os.path.exists(something): # this is a file or a directory try: modname = ".".join( modutils.modpath_from_file(something, path=additional_search_path)) except ImportError: modname = os.path.splitext(os.path.basename(something))[0] if os.path.isdir(something): filepath = os.path.join(something, "__init__.py") else: filepath = something else: # suppose it's a module or package modname = something try: filepath = modutils.file_from_modpath( modname.split("."), path=additional_search_path) if filepath is None: continue except (ImportError, SyntaxError) as ex: # The SyntaxError is a Python bug and should be # removed once we move away from imp.find_module: https://bugs.python.org/issue10588 errors.append({"key": "fatal", "mod": modname, "ex": ex}) continue filepath = os.path.normpath(filepath) modparts = (modname or something).split(".") try: spec = modutils.file_info_from_modpath(modparts, path=additional_search_path) except ImportError: # Might not be acceptable, don't crash. is_namespace = False is_directory = os.path.isdir(something) else: is_namespace = modutils.is_namespace(spec) is_directory = modutils.is_directory(spec) if not is_namespace: result.append({ "path": filepath, "name": modname, "isarg": True, "basepath": filepath, "basename": modname, }) has_init = ( not (modname.endswith(".__init__") or modname == "__init__") and os.path.basename(filepath) == "__init__.py") if has_init or is_namespace or is_directory: for subfilepath in modutils.get_module_files( os.path.dirname(filepath), black_list, list_all=is_namespace): if filepath == subfilepath: continue if _basename_in_blacklist_re(os.path.basename(subfilepath), black_list_re): continue modpath = _modpath_from_file(subfilepath, is_namespace, path=additional_search_path) submodname = ".".join(modpath) result.append({ "path": subfilepath, "name": submodname, "isarg": False, "basepath": filepath, "basename": modname, }) return result, errors
def expand_modules(files_or_modules, black_list, black_list_re): """take a list of files/modules/packages and return the list of tuple (file, module name) which have to be actually checked """ result = [] errors = [] for something in files_or_modules: if exists(something): # this is a file or a directory try: modname = '.'.join(modutils.modpath_from_file(something)) except ImportError: modname = splitext(basename(something))[0] if isdir(something): filepath = join(something, '__init__.py') else: filepath = something else: # suppose it's a module or package modname = something try: filepath = modutils.file_from_modpath(modname.split('.')) if filepath is None: continue except (ImportError, SyntaxError) as ex: # FIXME p3k : the SyntaxError is a Python bug and should be # removed as soon as possible http://bugs.python.org/issue10588 errors.append({'key': 'fatal', 'mod': modname, 'ex': ex}) continue filepath = normpath(filepath) modparts = (modname or something).split('.') try: spec = modutils.file_info_from_modpath(modparts, path=sys.path) except ImportError: # Might not be acceptable, don't crash. is_namespace = False is_directory = isdir(something) else: is_namespace = spec.type == modutils.ModuleType.PY_NAMESPACE is_directory = spec.type == modutils.ModuleType.PKG_DIRECTORY if not is_namespace: result.append({ 'path': filepath, 'name': modname, 'isarg': True, 'basepath': filepath, 'basename': modname }) has_init = ( not (modname.endswith('.__init__') or modname == '__init__') and '__init__.py' in filepath) if has_init or is_namespace or is_directory: for subfilepath in modutils.get_module_files( dirname(filepath), black_list, list_all=is_namespace): if filepath == subfilepath: continue if _basename_in_blacklist_re(basename(subfilepath), black_list_re): continue modpath = _modpath_from_file(subfilepath, is_namespace) submodname = '.'.join(modpath) result.append({ 'path': subfilepath, 'name': submodname, 'isarg': False, 'basepath': filepath, 'basename': modname }) return result, errors
def expand_modules(files_or_modules, black_list, black_list_re): """take a list of files/modules/packages and return the list of tuple (file, module name) which have to be actually checked """ result = [] errors = [] for something in files_or_modules: if basename(something) in black_list: continue if _basename_in_blacklist_re(basename(something), black_list_re): continue if exists(something): # this is a file or a directory try: modname = ".".join(modutils.modpath_from_file(something)) except ImportError: modname = splitext(basename(something))[0] if isdir(something): filepath = join(something, "__init__.py") else: filepath = something else: # suppose it's a module or package modname = something try: filepath = modutils.file_from_modpath(modname.split(".")) if filepath is None: continue except (ImportError, SyntaxError) as ex: # FIXME p3k : the SyntaxError is a Python bug and should be # removed as soon as possible http://bugs.python.org/issue10588 errors.append({"key": "fatal", "mod": modname, "ex": ex}) continue filepath = normpath(filepath) modparts = (modname or something).split(".") try: spec = modutils.file_info_from_modpath(modparts, path=sys.path) except ImportError: # Might not be acceptable, don't crash. is_namespace = False is_directory = isdir(something) else: is_namespace = modutils.is_namespace(spec) is_directory = modutils.is_directory(spec) if not is_namespace: result.append( { "path": filepath, "name": modname, "isarg": True, "basepath": filepath, "basename": modname, } ) has_init = ( not (modname.endswith(".__init__") or modname == "__init__") and basename(filepath) == "__init__.py" ) if has_init or is_namespace or is_directory: for subfilepath in modutils.get_module_files( dirname(filepath), black_list, list_all=is_namespace ): if filepath == subfilepath: continue if _basename_in_blacklist_re(basename(subfilepath), black_list_re): continue modpath = _modpath_from_file(subfilepath, is_namespace) submodname = ".".join(modpath) result.append( { "path": subfilepath, "name": submodname, "isarg": False, "basepath": filepath, "basename": modname, } ) return result, errors
def test_unicode_in_package_init(self) -> None: # file_from_modpath should not crash when reading an __init__ # file with unicode characters. modutils.file_from_modpath(["data", "unicode_package", "core"])
def test_builtin(self) -> None: self.assertIsNone(modutils.file_from_modpath(["sys"]))
def test_site_packages(self) -> None: filename = _get_file_from_object(modutils) result = modutils.file_from_modpath(["astroid", "modutils"]) self.assertEqual(os.path.realpath(result), os.path.realpath(filename))
def test_std_lib(self): from os import path self.assertEqual(path.realpath(modutils.file_from_modpath(['os', 'path']).replace('.pyc', '.py')), path.realpath(path.__file__.replace('.pyc', '.py')))
def test_site_packages(self): self.assertEqual( os.path.realpath( modutils.file_from_modpath(['astroid', 'modutils'])), os.path.realpath(modutils.__file__.replace('.pyc', '.py')))
def expand_modules(files_or_modules, black_list, black_list_re): """take a list of files/modules/packages and return the list of tuple (file, module name) which have to be actually checked """ result = [] errors = [] for something in files_or_modules: if exists(something): # this is a file or a directory try: modname = '.'.join(modutils.modpath_from_file(something)) except ImportError: modname = splitext(basename(something))[0] if isdir(something): filepath = join(something, '__init__.py') else: filepath = something else: # suppose it's a module or package modname = something try: filepath = modutils.file_from_modpath(modname.split('.')) if filepath is None: continue except (ImportError, SyntaxError) as ex: # FIXME p3k : the SyntaxError is a Python bug and should be # removed as soon as possible http://bugs.python.org/issue10588 errors.append({'key': 'fatal', 'mod': modname, 'ex': ex}) continue filepath = normpath(filepath) modparts = (modname or something).split('.') try: spec = modutils.file_info_from_modpath(modparts, path=sys.path) except ImportError: # Might not be acceptable, don't crash. is_namespace = False is_directory = isdir(something) else: is_namespace = spec.type == modutils.ModuleType.PY_NAMESPACE is_directory = spec.type == modutils.ModuleType.PKG_DIRECTORY if not is_namespace: result.append({'path': filepath, 'name': modname, 'isarg': True, 'basepath': filepath, 'basename': modname}) has_init = (not (modname.endswith('.__init__') or modname == '__init__') and '__init__.py' in filepath) if has_init or is_namespace or is_directory: for subfilepath in modutils.get_module_files(dirname(filepath), black_list, list_all=is_namespace): if filepath == subfilepath: continue if _basename_in_blacklist_re(basename(subfilepath), black_list_re): continue modpath = _modpath_from_file(subfilepath, is_namespace) submodname = '.'.join(modpath) result.append({'path': subfilepath, 'name': submodname, 'isarg': False, 'basepath': filepath, 'basename': modname}) return result, errors