def test_extendning(self):
c1 = Components('1')
self.assertEqual(c1.__bases__, ())
c2 = Components('2', (c1, ))
self.assertTrue(c2.__bases__ == (c1, ))
test_object1 = U1(1)
test_object2 = U1(2)
test_object3 = U12(1)
test_object4 = U12(3)
self.assertEqual(len(list(c1.registeredUtilities())), 0)
self.assertEqual(len(list(c2.registeredUtilities())), 0)
c1.registerUtility(test_object1)
self.assertEqual(len(list(c1.registeredUtilities())), 1)
self.assertEqual(len(list(c2.registeredUtilities())), 0)
self.assertEqual(c1.queryUtility(I1), test_object1)
self.assertEqual(c2.queryUtility(I1), test_object1)
c1.registerUtility(test_object2)
self.assertEqual(len(list(c1.registeredUtilities())), 1)
self.assertEqual(len(list(c2.registeredUtilities())), 0)
self.assertEqual(c1.queryUtility(I1), test_object2)
self.assertEqual(c2.queryUtility(I1), test_object2)
c3 = Components('3', (c1, ))
c4 = Components('4', (c2, c3))
self.assertEqual(c4.queryUtility(I1), test_object2)
c1.registerUtility(test_object3, I2)
self.assertEqual(c4.queryUtility(I2), test_object3)
c3.registerUtility(test_object4, I2)
self.assertEqual(c4.queryUtility(I2), test_object4)
@adapter(I1)
def handle1(x):
self.assertEqual(x, test_object1)
def handle(*objects):
self.assertEqual(objects, (test_object1, ))
@adapter(I1)
def handle3(x):
self.assertEqual(x, test_object1)
@adapter(I1)
def handle4(x):
self.assertEqual(x, test_object1)
c1.registerHandler(handle1, info=u'First handler')
c2.registerHandler(handle, required=[U])
c3.registerHandler(handle3)
c4.registerHandler(handle4)
c4.handle(test_object1)
def __init__(self):
self.registry = Components('Testing')
self.old = getSiteManager.sethook(lambda: self.registry)
self.instances.add(self)
if not self.__class__.atexit_setup:
atexit.register(self.atexit)
self.__class__.atexit_setup = True
def test_nested(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface.registry import Components
from guillotina.component import get_global_components
from guillotina.component.tests.examples import ConformsToIComponentLookup
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Global(object):
def __init__(self, context):
self.context = context
@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 = get_global_components()
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 test_hit_in_current_site(self):
from zope.component._api import getSiteManager
from zope.component.globalregistry import getGlobalSiteManager
from zope.interface.registry import Components
from zope.interface import Interface
from zope.interface.interfaces import IInterface
class ILocal(Interface):
pass
class IGlobal(Interface):
pass
gsm = getGlobalSiteManager()
site_man = Components(bases=(gsm,))
def get(_context=None):
return site_man
getSiteManager.sethook(get)
self.addCleanup(getSiteManager.reset)
gsm.registerUtility(IGlobal, IInterface, 'foo')
site_man.registerUtility(ILocal, IInterface, 'bar')
result = self._callFUT(None)
self.assertEqual(len(result), 2)
self.assertIn(ILocal, result)
self.assertIn(IGlobal, result)
getSiteManager.reset()
result = self._callFUT(None)
self.assertEqual(len(result), 1)
self.assertIn(IGlobal, result)
def test_nested(self):
from zope.component import getGlobalSiteManager
from zope.component.interfaces import IComponentLookup
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')
self.assertTrue(IComponentLookup(util1) is sm1)
self.assertTrue(self._callFUT(util1, IMyUtility, 'myutil') is gutil)
util1_1 = _makeMyUtility('one-one', sm1_1)
sm1_1.registerUtility(util1_1, IMyUtility, 'myutil')
self.assertTrue(IComponentLookup(util1_1) is sm1_1)
self.assertTrue(self._callFUT(util1_1, IMyUtility, 'myutil') is util1)
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)
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 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 populate_components():
def factory(o):
return 42
pop_components = Components()
for iface in ifaces:
for other_iface in ifaces:
pop_components.registerAdapter(factory, (iface, ),
other_iface,
event=False)
return pop_components
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 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
from zope.component._compat import _BLANK
registry = Components()
def dummy(context=None):
return registry
getSiteManager.sethook(dummy)
try:
self._callFUT('registerUtility', comp, IApp, _BLANK)
self.assertTrue(registry.getUtility(IApp) is comp)
finally:
getSiteManager.reset()
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)
def test_registration_with_custom_registry():
from pseud.utils import (get_rpc_callable,
registry,
register_rpc,
)
local_registry = Components(name='local',
bases=(registry,))
@register_rpc(name='try_to_call_me')
def callme(*args, **kw):
return 'global'
@register_rpc(name='try_to_call_me',
registry=local_registry)
def callme2(*args, **kw):
return 'local'
assert get_rpc_callable('try_to_call_me')() == 'global'
assert get_rpc_callable('try_to_call_me',
registry=local_registry)() == 'local'
def __init__(self, configuration=None):
"""
Use configuration and dbConfiguration objects to setup your application.
Events:
- init(configuration)
"""
self.registry = Components()
self.configuration = configuration
self.dbConfiguration = None
# set id for logging
if configuration:
self.id = configuration.id
else:
self.id = __name__
self.__name__ = u""
self.__parent__ = None
self.__acl__ = []
# development
self.debug = False
self.reloadExtensions = False
# v0.9.12: moved _meta to configuration.meta
# meta fields are now handled by the application configuration
# self._meta = copy.deepcopy(SystemFlds)
# default root name if multiple
self._defaultRoot = ""
# cache database structure
self._structure = PoolStructure()
self._dbpool = None
self.log = logging.getLogger(self.id)
self.log.debug("Initialize %s", repr(configuration))
self.Signal("init", configuration=configuration)
self.starttime = 0
def test_register_in_current_site(self):
from zope.component._api import getSiteManager
from zope.component.globalregistry import getGlobalSiteManager
from zope.interface.registry import Components
from zope.interface import Interface
from zope.interface.interfaces import IInterface
class IFoo(Interface):
pass
site_man = Components()
def get(_context=None):
return site_man
getSiteManager.sethook(get)
self.addCleanup(getSiteManager.reset)
self._callFUT('foo', IFoo)
self.assertIs(site_man.getUtility(IInterface, name='foo'),
IFoo)
self.assertIsNone(
getGlobalSiteManager().queryUtility(IInterface, name='foo')
)
def __init__(self):
self._component = Components()
def app_registry():
"""
See also app_registry_mock.
:return:
"""
return Components()
runner.bench_time_func(
'read __doc__', # stored in Python instance dictionary directly
bench_getattr,
'__doc__',
inner_loops=INNER * 10)
runner.bench_time_func(
'read providedBy', # from the class, wrapped into a method object.
bench_getattr,
'providedBy',
inner_loops=INNER * 10)
runner.bench_time_func('query adapter (no registrations)',
bench_query_adapter,
Components(),
inner_loops=1)
def populate_components():
def factory(o):
return 42
pop_components = Components()
for iface in ifaces:
for other_iface in ifaces:
pop_components.registerAdapter(factory, (iface, ),
other_iface,
event=False)
return pop_components
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()
'''
JSON Adapters
Created on May 30, 2013
@author: Edward Easton
'''
import json
import datetime
import logging
from zope.interface.registry import Components
from zope.interface import Interface, providedBy
# Singleton type registry
_TYPE_REGISTRY = Components()
_marker = object()
def get_log():
return logging.getLogger('pp.utils.json')
class IJSONAdapter(Interface):
"""
Marker interface for objects that can convert an arbitrary object
into a JSON-serializable primitive.
"""
def get_adapters():
import zope.interface
import zope.interface.verify
from zope.interface.adapter import AdapterRegistry
from zope.interface.registry import Components
registry = Components()
class IFoo(zope.interface.Interface):
"""Foo blah blah"""
x = zope.interface.Attribute("""X blah blah""")
class IBaz(IFoo):
"""Baz blah"""
def eek(a=1):
"""eek in baz blah"""
@zope.interface.implementer(IBaz)
class Bazz:
def __init__(self, x=None):
self.x = x
def eek(self, a=1):
return a
assert IFoo.implementedBy(Bazz)
assert IBaz.implementedBy(Bazz)
bazz = Bazz()
def global_registry():
return _global_registry or Components()
def setUp(self):
self.components = Components('comps')
def get_registry():
global _registry
if _registry is None:
_registry = Components()
return _registry
