pkg_resources.iter_entry_points

from pkg_resources import iter_entry_points
import os
import logging
log = logging.getLogger(__name__)
 
from pkg_resources import resource_string, resource_filename
from midgardmvc.components.base import load_config

def load_all(global_conf):
    global _project_root, _components
 
    _project_root = global_conf["here"]
 
    for entry_point in iter_entry_points(group='midgardmvc.component', name=None):
        log.debug("Loading component: %s" % entry_point.name)

def load(name):
    global _components
 
    if not _components.has_key(name):
        for entry_point in iter_entry_points(group='midgardmvc.component', name=name):
            log.debug("Loading component: %s" % entry_point.name)
            _components[entry_point.name] = _load_instance(entry_point)

def findfabfiles():
    from pkg_resources import iter_entry_points
 
    fabfiles = []
    for ep in iter_entry_points(
	group='fabric',
	# Use None to get all entry point names

 
from paste.util.import_string import eval_import
from multi import MultiHandler, status_checker
from pkg_resources import iter_entry_points, load_entry_point
from paste.deploy.converters import asbool
 
import paste.httpexceptions

def get_methods():
    """Get a dictionary of the available method entry points."""
    available_methods = {}
    for method_handler in iter_entry_points(group='authkit.method', name=None):
        available_methods[method_handler.name] = method_handler
    return available_methods
 

import logging
from pkg_resources import iter_entry_points
 
log = logging.getLogger(__name__)
 
# Entry point group. 
GROUP_NAME = "ckan.plugins"

def load_all(config):
    plugins = config.get('ckan.plugins', '')
    log.info("Loading plugins: %s" % plugins)
    for plugin in plugins.split():
        for entry_point in iter_entry_points(group=GROUP_NAME, name=plugin):
            load(plugin, entry_point, config)
            break

from bn import AttributeDict
from pkg_resources import iter_entry_points
 
available_plugins = {}
insert_record = {}
update_config = {}
engine_name = {}

def load_available_plugins(plugins=[]):
    dist_plugins = {}
    if not plugins:
        for ep in iter_entry_points(
            group='database.engine',
            # Use None to get all entry point names
            name=None,

import os
import sys
import pdb
import shutil
from optparse import OptionParser
 
from pkg_resources import iter_entry_points

def iter_vudo_skins():
    """iterator for vudo skins"""
    for ep in iter_entry_points(group="vudo.skin"):
        try:
            skin_plugin = ep.load()
        except DistributionNotFound, e:
            print "*** the skin '%s' provided by module '%s' could not be "\

"""
 
from interface import interface
from pkg_resources import iter_entry_points
 
class IPlugin():
  # Returns true if plugin is enabled

  def __getentries__(self):
    """Returns plugin classes avialable"""
 
    self.__entries__ = []
    self.__invalid__ = []
 
    for e in iter_entry_points(group=self.__entry_point__):

from setuptools.command.sdist import sdist
from distutils.util import convert_path
from distutils.filelist import FileList
from pkg_resources import parse_requirements, safe_name, parse_version, \
    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename
from sdist import walk_revctrl
 

    def run(self):
        self.mkpath(self.egg_info)
        installer = self.distribution.fetch_build_egg
        for ep in iter_entry_points('egg_info.writers'):
            writer = ep.load(installer=installer)
            writer(self, ep.name, os.path.join(self.egg_info,ep.name))
 

from setuptools.command.sdist import sdist
from distutils.util import convert_path
from distutils.filelist import FileList
from pkg_resources import parse_requirements, safe_name, parse_version, \
    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename
from sdist import walk_revctrl
 

    def run(self):
        self.mkpath(self.egg_info)
        installer = self.distribution.fetch_build_egg
        for ep in iter_entry_points('egg_info.writers'):
            writer = ep.load(installer=installer)
            writer(self, ep.name, os.path.join(self.egg_info,ep.name))
 

import re
from ConfigParser import RawConfigParser
from os           import linesep, path
from pkg_resources import iter_entry_points, resource_stream
from sys          import argv
from weakref      import WeakValueDictionary
 

    def __iter__(self):
        for item in iter_entry_points(self.group):
            yield item.name
    def __getitem__(self, name):
        for item in iter_entry_points(self.group, name):
            return item.load()
        else: