docs: def importmodules(package_or_toc, ignore=None, recurse=False, silent=None):
      """
      Imports all the sub-modules of a package, a useful technique for developing
      plugins.  By default, this method will walk the directory structure looking
      for submodules and packages.  You can also specify a __toc__ attribute
      on the package to define the sub-modules that you want to import.
      
      :param      package_or_toc  | <package> || <str> filename
                  ignore          | [<str>, ..] || None
                  recurse         | <bool>
                  silent          | <bool>
      
      :usage      |>>> import projex
                  |>>> import projex.docgen
                  |>>> projex.importmodules(projex.docgen)
                  |[<projex.docgen.commands>, <projex.docgen.default_config>, ..]
      
      :return     [<module> || <package>, ..]
      """
      if package_or_toc in __IMPORTED:
          return
  
      __IMPORTED.add(package_or_toc)
  
      if silent is None:
          silent = os.environ.get('PROJEX_LOG_IMPORTS', 'False').lower() != 'true'
  
      toc = []
      output = []
      if ignore is None:
          ignore = []
  
      # import from a set toc file
      if type(package_or_toc) in (str, unicode):
          # import a toc file
          if os.path.isfile(package_or_toc):
              f = open(package_or_toc, 'r')
              toc = f.readlines()
              f.close()
  
          # import from a directory
          elif os.path.isdir(package_or_toc):
              toc, paths = findmodules(package_or_toc, recurse=recurse)
              for path in paths:
                  if path in sys.path:
                      sys.path.remove(path)
  
                  sys.path.insert(0, path)
  
          # import a module by string
          else:
              use_sub_modules = False
              if package_or_toc.endswith('.*'):
                  use_sub_modules = True
                  package_or_toc = package_or_toc[:-2]
  
              try:
                  __import__(package_or_toc)
                  module = sys.modules[package_or_toc]
              except ImportError as err:
                  if not silent:
                      logger.error('Unable to import module: %s', package_or_toc)
                      logger.debug(traceback.print_exc())
                  return []
              except KeyError:
                  if not silent:
                      logger.error('Unable to find module: %s', package_or_toc)
                  return []
  
              if use_sub_modules:
                  base = os.path.dirname(module.__file__)
                  for path in os.listdir(base):
                      if path.endswith('.py') and path != '__init__.py':
                          importmodules(package_or_toc + '.' + path.replace('.py', ''))
                      elif os.path.isdir(os.path.join(base, path)):
                          importmodules(package_or_toc + '.' + path)
              else:
                  return importmodules(module)
  
      # import from a given package
      else:
          toc = getattr(package_or_toc, '__toc__', [])
  
          if not toc:
              toc = []
              recurse = getattr(package_or_toc, '__recurse__', False)
              try:
                  paths = package_or_toc.__path__
              except AttributeError:
                  try:
                      paths = [os.path.dirname(package_or_toc.__file__)]
                  except AttributeError:
                      paths = []
  
              for path in paths:
                  data = findmodules(path, recurse=recurse)
                  toc += data[0]
                  for sub_path in data[1]:
                      if sub_path in sys.path:
                          sys.path.remove(sub_path)
  
                      sys.path.insert(0, sub_path)
  
              setattr(package_or_toc, '__toc__', toc)
  
      # import using standard means (successful for when dealing with 
      for modname in sorted(toc):
          # check against a callable ignore method
          if callable(ignore) and ignore(modname):
              continue
  
          elif type(modname) in (list, tuple) and modname not in ignore:
              continue
  
          # ignore preset options
          if modname.endswith('__init__'):
              continue
          elif modname.endswith('__plugins__'):
              continue
  
          try:
              output.append(sys.modules[modname])
              continue
          except KeyError:
              pass
  
          if not silent:
              logger.debug('Importing: %s' % modname)
          try:
              mod = importlib.import_module(modname)
              sys.modules[modname] = mod
              output.append(mod)
          except ImportError, err:
              if not silent:
                  logger.error('Error importing module: %s', modname)
                  logger.debug(traceback.print_exc())
  
      return output