code: def any_missing_maybe(self):  # pragma: nocover
          
          missing = []
          maybe = []
          for name in self.badmodules:
              if name in self.excludes:
                  continue
              i = name.rfind(".")
              if i < 0:
                  missing.append(name)
                  continue
              subname = name[i + 1:]
              pkgname = name[:i]
              pkg = self.modules.get(pkgname)
              if pkg is not None:
                  if pkgname in self.badmodules[name]:
                      # The package tried to import this module itself and
                      # failed. It's definitely missing.
                      missing.append(name)
                  elif subname in pkg.globalnames:
                      # It's a global in the package: definitely not missing.
                      pass
                  elif pkg.starimports:
                      # It could be missing, but the package did an "import *"
                      # from a non-Python module, so we simply can't be sure.
                      maybe.append(name)
                  else:
                      # It's not a global in the package, the package didn't
                      # do funny star imports, it's very likely to be missing.
                      # The symbol could be inserted into the package from the
                      # outside, but since that's not good style we simply list
                      # it missing.
                      missing.append(name)
              else:
                  missing.append(name)
          missing.sort()
          maybe.sort()
          return missing, maybe
docs: Return two lists, one with modules that are certainly missing
          and one with modules that *may* be missing. The latter names could
          either be submodules *or* just global names in the package.
  
          The reason it can't always be determined is that it's impossible to
          tell which names are imported when ``from module import *`` is done
          with an extension module, short of actually importing it.