public Object[] getCompletionVariants(
     String completionPrefix, PsiElement location, ProcessingContext context) {
   final List<LookupElement> result = new ArrayList<LookupElement>();
   final PsiElement resolved = myImportedModule.resolve();
   if (resolved instanceof PyFile) {
     final PyModuleType moduleType = new PyModuleType((PyFile) resolved, myImportedModule);
     result.addAll(
         moduleType.getCompletionVariantsAsLookupElements(location, context, false, false));
   } else if (resolved instanceof PsiDirectory) {
     final PsiDirectory dir = (PsiDirectory) resolved;
     if (PyUtil.isPackage(dir, location)) {
       if (ResolveImportUtil.getPointInImport(location) != PointInImport.NONE) {
         result.addAll(PyModuleType.getSubModuleVariants(dir, location, null));
       } else {
         result.addAll(
             PyModuleType.collectImportedSubmodulesAsLookupElements(
                 dir, location, context.get(CTX_NAMES)));
       }
     }
   }
   return ArrayUtil.toObjectArray(result);
 }
 public Object[] getCompletionVariants(
     String completionPrefix, PsiElement location, ProcessingContext context) {
   List<LookupElement> result = new ArrayList<LookupElement>();
   ScopeOwner scopeOwner = ScopeUtil.getScopeOwner(location);
   assert scopeOwner != null;
   final List<PyImportElement> importTargets = PyModuleType.getVisibleImports(scopeOwner);
   final int imported = myImportedModule.getImportedPrefix().getComponentCount();
   for (PyImportElement importTarget : importTargets) {
     final QualifiedName qName = importTarget.getImportedQName();
     if (qName != null && qName.matchesPrefix(myImportedModule.getImportedPrefix())) {
       final List<String> components = qName.getComponents();
       if (components.size() > imported) {
         String module = components.get(imported);
         result.add(LookupElementBuilder.create(module));
       }
     }
   }
   return result.toArray(new Object[result.size()]);
 }
 @Nullable
 @Override
 public List<? extends RatedResolveResult> resolveMember(
     @NotNull String name,
     @Nullable PyExpression location,
     @NotNull AccessDirection direction,
     @NotNull PyResolveContext resolveContext) {
   final PsiElement resolved = myImportedModule.resolve();
   if (resolved != null) {
     final PsiFile containingFile = location != null ? location.getContainingFile() : null;
     List<PsiElement> elements =
         Collections.singletonList(
             ResolveImportUtil.resolveChild(resolved, name, containingFile, false, true));
     final PyImportElement importElement = myImportedModule.getImportElement();
     final PyFile resolvedFile = PyUtil.as(resolved, PyFile.class);
     if (location != null
         && importElement != null
         && PyUtil.inSameFile(location, importElement)
         && ResolveImportUtil.getPointInImport(location) == PointInImport.NONE
         && resolved instanceof PsiFileSystemItem
         && (resolvedFile == null
             || !PyUtil.isPackage(resolvedFile)
             || resolvedFile.getElementNamed(name) == null)) {
       final List<PsiElement> importedSubmodules =
           PyModuleType.collectImportedSubmodules((PsiFileSystemItem) resolved, location);
       if (importedSubmodules != null) {
         final Set<PsiElement> imported = Sets.newHashSet(importedSubmodules);
         elements =
             ContainerUtil.filter(
                 elements,
                 new Condition<PsiElement>() {
                   @Override
                   public boolean value(PsiElement element) {
                     return imported.contains(element);
                   }
                 });
       }
     }
     return ResolveImportUtil.rateResults(elements);
   }
   return null;
 }