def visit_import_from(self, o: ImportFrom) -> None: module_id, _ = correct_relative_import(self.scope.current_module_id(), o.relative, o.id, self.is_package_init_file) for name, as_name in o.names: self.add_dependency(make_trigger(module_id + '.' + name))
def visit_import_all(self, o: ImportAll) -> None: module_id, _ = correct_relative_import(self.scope.current_module_id(), o.relative, o.id, self.is_package_init_file) # The current target needs to be rechecked if anything "significant" changes in the # target module namespace (as the imported definitions will need to be updated). self.add_dependency(make_wildcard_trigger(module_id))
def visit_import_from(self, o: ImportFrom) -> None: if self.use_logical_deps(): # Just importing a name doesn't create a logical dependency. return module_id, _ = correct_relative_import(self.scope.current_module_id(), o.relative, o.id, self.is_package_init_file) for name, as_name in o.names: self.add_dependency(make_trigger(module_id + '.' + name))
def process_import(self, imp: Union[ImportFrom, ImportAll]) -> None: import_id, ok = correct_relative_import( self.cur_mod_id, imp.relative, imp.id, self.cur_mod_node.is_package_init_file()) if ok and import_id in self.modules: kind = TYPE_PRECISE else: kind = TYPE_ANY self.record_line(imp.line, kind)
def create_indirect_imported_name( file_node: MypyFile, module: str, relative: int, imported_name: str) -> Optional[SymbolTableNode]: """Create symbol table entry for a name imported from another module. These entries act as indirect references. """ target_module, ok = correct_relative_import( file_node.fullname, relative, module, file_node.is_package_init_file()) if not ok: return None target_name = '%s.%s' % (target_module, imported_name) link = ImportedName(target_name) # Use GDEF since this refers to a module-level definition. return SymbolTableNode(GDEF, link)
def get_import_star_modules(api: SemanticAnalyzerPass2, module: MypyFile) -> List[str]: import_star_modules = [] for module_import in module.imports: # relative import * are not resolved by mypy if isinstance(module_import, ImportAll) and module_import.relative: absolute_import_path, correct = correct_relative_import( module.fullname(), module_import.relative, module_import.id, is_cur_package_init_file=False) if not correct: return [] for path in [absolute_import_path] + get_import_star_modules( api, module=api.modules.get(absolute_import_path)): if path not in import_star_modules: import_star_modules.append(path) return import_star_modules
def create_indirect_imported_name(file_node: MypyFile, module: str, relative: int, imported_name: str) -> Optional[SymbolTableNode]: """Create symbol table entry for a name imported from another module. These entries act as indirect references. """ target_module, ok = correct_relative_import( file_node.fullname(), relative, module, file_node.is_package_init_file()) if not ok: return None target_name = '%s.%s' % (target_module, imported_name) link = ImportedName(target_name) # Use GDEF since this refers to a module-level definition. return SymbolTableNode(GDEF, link)
def find_import_name(import_node, line, column, suite, mypy_file: MypyFile): assert suite[0] == symbol.file_input stmt = suite[1] assert stmt[0] == symbol.stmt simple_stmt = stmt[1] assert simple_stmt[0] == symbol.simple_stmt small_stmt = simple_stmt[1] assert small_stmt[0] == symbol.small_stmt import_stmt = small_stmt[1] assert import_stmt[0] == symbol.import_stmt if isinstance(import_node, Import): import_name = import_stmt[1] assert import_name[0] == symbol.import_name dotted_as_names = import_name[2] for dotted_as_name in dotted_as_names[1:]: if dotted_as_name[0] != symbol.dotted_as_name: continue dotted_name = dotted_as_name[1] name = get_dotted_name_at_position(dotted_name, line, column) if name: return name, None elif isinstance(import_node, ImportAll): import_from = import_stmt[1] assert import_from[0] == symbol.import_from for element in import_from[2:]: if element[0] == token.NAME and element[1] == 'import': break elif element[0] == symbol.dotted_name: name = get_dotted_name_at_position(element, line, column) if name: import_id, ok = correct_relative_import( mypy_file.fullname(), import_node.relative, name, mypy_file.is_package_init_file()) if ok: return import_id, None elif isinstance(import_node, ImportFrom): import_from = import_stmt[1] assert import_from[0] == symbol.import_from import_as_names = None for element in import_from[2:]: if element[0] == symbol.dotted_name: name = get_dotted_name_at_position(element, line, column) if name: import_id, ok = correct_relative_import( mypy_file.fullname(), import_node.relative, name, mypy_file.is_package_init_file()) if ok: return import_id, None elif element[0] == symbol.import_as_names: for import_as_name in element[1:]: if import_as_name[0] == symbol.import_as_name: name = import_as_name[1] assert name[0] == token.NAME if token_contains_offset(name[2], name[3], len(name[1]), line, column): import_id, ok = correct_relative_import( mypy_file.fullname(), import_node.relative, import_node.id, mypy_file.is_package_init_file()) if ok: return import_id, name[1] return None, None