Python registry.Components类代码示例

 def test_hit_via_sm(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.interface.registry import Components
     from zope.component import getGlobalSiteManager
     from zope.component.tests.examples import ConformsToIComponentLookup
     class IFoo(Interface):
         pass
     class IBar(Interface):
         pass
     @implementer(IFoo)
     class Global(object):
         __init__ = fails_if_called(self)
     @implementer(IFoo)
     class Local(object):
         def __init__(self, context):
             self.context = context
     @implementer(IBar)
     class Bar(object):
         pass
     class Context(ConformsToIComponentLookup):
         def __init__(self, sm):
             self.sitemanager = sm
     gsm = getGlobalSiteManager()
     gsm.registerAdapter(Global, (IBar,), IFoo, '')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1.registerAdapter(Local, (IBar,), IFoo, '')
     bar = Bar()
     adapted = self._callFUT(bar, IFoo, context=Context(sm1))
     self.assertTrue(adapted.__class__ is Local)
     self.assertTrue(adapted.context is bar)

 def __init__(self, *arg, **kw):
     # add a registry-instance-specific lock, which is used when the lookup
     # cache is mutated
     self._lock = threading.Lock()
     # add a view lookup cache
     self._clear_view_lookup_cache()
     Components.__init__(self, *arg, **kw)

def initialize(packages=None, excludes=(), reg=None):
    """ Load memphis packages, scan and execute all configuration
    directives. """

    if reg is None:
        reg = Components('memphis')
        reg.registerHandler(objectEventNotify, (IObjectEvent,))

    sys.modules['memphis.config'].registry = reg
    sys.modules['memphis.config.api'].registry = reg

    def exclude_filter(modname):
        if modname in packages:
            return True
        return exclude(modname, excludes)

    # list all packages
    if packages is None:
        packages = loadPackages(excludes=excludes)
        packages.extend([mod for mod in mods if exclude_filter(mod)])
    else:
        packages = loadPackages(packages, excludes=excludes)

    # scan packages and load all actions
    seen = set()
    actions = []

    for pkg in packages:
        actions.extend(directives.scan(pkg, seen, exclude_filter))

    # execute actions
    actions = directives.resolveConflicts(actions)
    for action in actions:
        action()

    class JSON(object):

        def __init__(self, serializer=json.dumps, adapters=(), **kw):
            """ Any keyword arguments will be passed to the ``serializer``
            function."""
            self.serializer = serializer
            self.kw = kw
            self.components = Components()

        def add_adapter(self, type_or_iface, adapter):
            self.components.registerAdapter(adapter, (type_or_iface,),
                                            IJSONAdapter)

        def __call__(self, info):
            def _render(value, system):
                request = system.get('request')
                if request is not None:
                    response = request.response
                    ct = response.content_type
                    if ct == response.default_content_type:
                        response.content_type = 'application/json'
                default = self._make_default(request)
                return self.serializer(value, default=default, **self.kw)

            return _render

        def _make_default(self, request):
            def default(obj):
                obj_iface = providedBy(obj)
                adapters = self.components.adapters
                result = adapters.lookup((obj_iface,), IJSONAdapter,
                                         default=None)
                return result(obj, request)
            return default

 def test_init_forwards_kw(self):
     from zope.interface import Interface
     from zope.interface.registry import Components
     dummy = object()
     c = Components()
     c.registerUtility(dummy, Interface)
     registry = self._makeOne(bases=(c,))
     self.assertEqual(registry.getUtility(Interface), dummy)

 def __init__(self, package_name=CALLER_PACKAGE, *args, **kw):
     # add a registry-instance-specific lock, which is used when the lookup
     # cache is mutated
     self._lock = threading.Lock()
     # add a view lookup cache
     self._clear_view_lookup_cache()
     if package_name is CALLER_PACKAGE:
         package_name = caller_package().__name__
     Components.__init__(self, package_name, *args, **kw)
     dict.__init__(self)

    def test_uses_configured_site_manager(self):
        from zope.interface.registry import Components
        from zope.component import getSiteManager
        from zope.component.testfiles.components import comp, IApp

        registry = Components()
        def dummy(context=None):
            return registry
        getSiteManager.sethook(dummy)

        try:
            self._callFUT('registerUtility', comp, IApp, u'')
            self.assertTrue(registry.getUtility(IApp) is comp)
        finally:
            getSiteManager.reset()

 def __init__(self, serializer=json.dumps, adapters=(), **kw):
     """ Any keyword arguments will be passed to the ``serializer``
     function."""
     self.serializer = serializer
     self.kw = kw
     self.components = Components()
     for type, adapter in adapters:
         self.add_adapter(type, adapter)

class PackageConfigurator(object):
    default_depth = 3

    def __init__(self, registry, resolve=None, target='includeme'):
        self.registry = registry
        self._resolve = resolve
        self._target = target
        self._depth = self.default_depth
        self._configurator_registry = Components()

    def add_configurator(self, configurator, name=''):
        self._configurator_registry.registerUtility(configurator, IConfigurator, name)

    def include(self, name, *args, **kwargs):
        _logger.debug('start include: name=%s, args=%s, kwds=%s', name, args, kwargs)
        includeme = name if callable(name) else get_includeme(name, resolve=self._resolve, depth=self._depth)
        _logger.debug('include -> %s.%s', includeme.__module__, includeme.__name__)
        return includeme(self)

    def scan(self, package=None, **kw):
        name = 'scan'
        if package is None:
            package = '.'

        if isinstance(package, (six.string_types, six.text_type, six.binary_type)):
            package = get_abs_dotted_name_caller_module(package, **kw)

        for cfg in self._configurator_registry.getAllUtilitiesRegisteredFor(IConfigurator):
            if hasattr(cfg, name) and callable(getattr(cfg, name)):
                _logger.debug('scanning...: %s: %s', cfg.__module__, package)
                cfg.scan(package)

    def __getattr__(self, name):
        if name.startswith('_'):
            raise AttributeError(name)

        configs = [cfg
                   for cfg in self._configurator_registry.getAllUtilitiesRegisteredFor(IConfigurator)
                   if hasattr(cfg, name) and callable(getattr(cfg, name))]

        if configs:
            for config in configs:
                return getattr(config, name)
        else:
            raise AttributeError(name)

def main():
    registry = Components()
    bootstrap(registry)

    session_factory = registry.queryUtility(IDBSessionFactory, "master")
    session = session_factory()
    a = MainTable()
    a.name = "test"
    session.add(a)
    print(session.get_bind())
    session.commit()

    session_factory = registry.queryUtility(IDBSessionFactory, "other")
    session = session_factory()
    a = OtherTable()
    a.name_other = "test"
    session.add(a)
    print(session.get_bind())
    session.commit()

 def test_nested(self):
     from zope.component import getGlobalSiteManager
     from zope.interface.registry import Components
     gsm = getGlobalSiteManager()
     gutil = _makeMyUtility('global', gsm)
     gsm.registerUtility(gutil, IMyUtility, 'myutil')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1_1 = Components('sm1_1', bases=(sm1, ))
     util1 = _makeMyUtility('one', sm1)
     sm1.registerUtility(util1, IMyUtility, 'myutil')
     util1_1 = _makeMyUtility('one-one', sm1_1)
     sm1_1.registerUtility(util1_1, IMyUtility, 'myutil')
     myregistry = Components()
     custom_util = _makeMyUtility('my_custom_util', myregistry)
     myregistry.registerUtility(custom_util, IMyUtility, 'my_custom_util')
     sm1.__bases__ = (myregistry,) + sm1.__bases__
     # Both the ``myregistry`` and global utilities should be available:
     self.assertTrue(self._callFUT(sm1, IMyUtility, 'my_custom_util')
                                         is custom_util)
     self.assertTrue(self._callFUT(sm1, IMyUtility, 'myutil') is gutil)

 def test_passwords(self):
     from zope.interface.registry import Components
     from alpaca.common.domain.user import User
     from alpaca.common.utilities.interfaces import IPasswordProcessor
     from alpaca.common.utilities.pbkdf2_password_processor import (
         PBKDF2PasswordProcessor
     )
     processor = PBKDF2PasswordProcessor()
     registry = Components()
     registry.registerUtility(
         processor,
         IPasswordProcessor,
         'pbkdf2'
     )
     user = User()
     user.set_password('łąki łan 123', 'pbkdf2', processor)
     self.assertEqual(user.password_processor, 'pbkdf2')
     self.assertTrue(bool(user.password_hash))
     self.assertLessEqual(len(user.password_hash), 100)
     self.assertFalse(user.password_equals('łąki łany 123', registry))
     self.assertTrue(user.password_equals('łąki łan 123', registry))

 def test_nested(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.interface.registry import Components
     from zope.component import getGlobalSiteManager
     from zope.component.tests.examples import ConformsToIComponentLookup
     class IFoo(Interface):
         pass
     class IBar(Interface):
         pass
     class IBaz(Interface):
         pass
     @implementer(IBar)
     class Bar(object):
         pass
     @implementer(IBaz)
     class Baz(object):
         pass
     @implementer(IFoo)
     class Global(object):
         def __init__(self, first, second):
             self.first, self.second = first, second
     @implementer(IFoo)
     class Local(object):
         def __init__(self, first, second):
             self.first, self.second = first, second
     class Context(ConformsToIComponentLookup):
         def __init__(self, sm):
             self.sitemanager = sm
     gsm = getGlobalSiteManager()
     gsm.registerAdapter(Global, (IBar, IBaz), IFoo, '')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1.registerAdapter(Local, (IBar, IBaz), IFoo, '')
     bar = Bar()
     baz = Baz()
     adapted = self._callFUT((bar, baz), IFoo, '', context=Context(sm1))
     self.assertTrue(adapted.__class__ is Local)
     self.assertTrue(adapted.first is bar)
     self.assertTrue(adapted.second is baz)

def main(argv=sys.argv[1:]):
    reg = Components()
    reg.registerUtility(GoogleVisionAPIFaceDetection(),
                        IDetection, 'gcp')
    reg.registerUtility(MSProjectoxfordDetection(get_ms_param()['API_TOKEN']),
                        IDetection, 'ms')
    reg.registerUtility(AkamaiCrop(),
                        ICrop, 'akamai')

    parser = argparse.ArgumentParser()
    parser.add_argument('mode', help='gcp or ms')
    parser.add_argument('target', help='url or path')
    parser.add_argument('--crop', default='akamai')
    args = parser.parse_args(argv)

    detect = reg.queryUtility(IDetection, args.mode)
    result = detect(args.target)
    crop = AkamaiCrop()
    url = crop(result)
    print(url)

class TestAdapter(unittest.TestCase):

    def setUp(self):
        self.components = Components('comps')

    def test_register_and_unregister_adapter(self):
        self.components.registerAdapter(A12_1)

        multi_adapter = self.components.getMultiAdapter(
            (U1(1), U12(2)), IA1)
        self.assertEqual(multi_adapter.__class__, A12_1)
        self.assertEqual(repr(multi_adapter), 'A12_1(U1(1), U12(2))')

        self.assertTrue(self.components.unregisterAdapter(A12_1))
        self.assertRaises(
            ComponentLookupError,
            self.components.getMultiAdapter,
            (U1(1), U12(2)),
            IA1
            )

    def test_register_and_unregister_adapter_with_two_interfaces(self):
        self.assertRaises(TypeError, self.components.registerAdapter,
                          A1_12)
        self.components.registerAdapter(A1_12,
                                        provided=IA2)

        multi_adapter = self.components.getMultiAdapter((U1(1),), IA2)
        self.assertEqual(multi_adapter.__class__, A1_12)
        self.assertEqual(repr(multi_adapter), 'A1_12(U1(1))')

        self.assertRaises(TypeError, self.components.unregisterAdapter, A1_12)
        self.assertTrue(self.components.unregisterAdapter(A1_12, provided=IA2))
        self.assertRaises(ComponentLookupError,
                          self.components.getMultiAdapter, (U1(1),), IA2)

    def test_register_and_unregister_adapter_with_no_interfaces(self):
        self.assertRaises(TypeError, self.components.registerAdapter, A12_)

        self.components.registerAdapter(A12_, provided=IA2)
        multi_adapter = self.components.getMultiAdapter((U1(1), U12(2)), IA2)
        self.assertEqual(multi_adapter.__class__, A12_)
        self.assertEqual(repr(multi_adapter), 'A12_(U1(1), U12(2))')

        self.assertRaises(TypeError, self.components.unregisterAdapter, A12_)
        self.assertTrue(self.components.unregisterAdapter(A12_, provided=IA2))
        self.assertRaises(ComponentLookupError,
                          self.components.getMultiAdapter, (U1(1), U12(2)), IA2)

    def test_reg_and_unreg_adp_with_no___component_adapts___attribute(self):
        self.assertRaises(TypeError, self.components.registerAdapter, A_2)
        self.components.registerAdapter(A_2, required=[I3])
        self.assertTrue(self.components.unregisterAdapter(A_2, required=[I3]))

    def test_register_and_unregister_class_specific(self):
        self.components.registerAdapter(A_3, required=[U],
                                        info=u'Really class specific')
        self.assertTrue(self.components.unregisterAdapter(required=[U],
                                                          provided=IA3))
      
    def test_registered_adapters_and_sorting(self):
        self.components.registerAdapter(A12_1)
        self.components.registerAdapter(A1_12, provided=IA2)
        self.components.registerAdapter(A12_, provided=IA2)
        self.components.registerAdapter(A_2, required=[I3])
        self.components.registerAdapter(A_3, required=[U],
                                        info=u'Really class specific')

        sorted_adapters = sorted(self.components.registeredAdapters())
        sorted_adapters_name = map(lambda x: getattr(x, 'name'),
                                   sorted_adapters)
        sorted_adapters_provided = map(lambda x: getattr(x, 'provided'),
                                       sorted_adapters) 
        sorted_adapters_required = map(lambda x: getattr(x, 'required'),
                                       sorted_adapters)
        sorted_adapters_info = map(lambda x: getattr(x, 'info'),
                                   sorted_adapters)

        self.assertEqual(len(sorted_adapters), 5)
        self.assertEqual(sorted_adapters_name, [u'', u'', u'', u'', u''])
        self.assertEqual(sorted_adapters_provided, [IA1,
                                                    IA2,
                                                    IA2,
                                                    IA2,
                                                    IA3])

        self.assertEqual(sorted_adapters_required, [(I1, I2),
                                                    (I1, I2),
                                                    (I1,),
                                                    (I3,),
                                                    (implementedBy(U),)])
        self.assertEqual(sorted_adapters_info,
                         [u'', u'', u'', u'', u'Really class specific'])

    def test_get_none_existing_adapter(self):
        self.assertRaises(ComponentLookupError,
                          self.components.getMultiAdapter, (U(1),), IA1)

    def test_query_none_existing_adapter(self):
        self.assertTrue(self.components.queryMultiAdapter((U(1),), IA1) is None)
#.........这里部分代码省略.........