def grok(self, name, factory, context, module_info, templates):
adapter_context = util.determine_class_context(factory, context)
provides = util.class_annotation(factory, 'grok.provides', None)
if provides is None:
base_interfaces = interface.implementedBy(grok.Annotation)
factory_interfaces = interface.implementedBy(factory)
real_interfaces = list(factory_interfaces - base_interfaces)
util.check_implements_one_from_list(real_interfaces, factory)
provides = real_interfaces[0]
key = util.class_annotation(factory, 'grok.name', None)
if key is None:
key = factory.__module__ + '.' + factory.__name__
@component.adapter(adapter_context)
@interface.implementer(provides)
def getAnnotation(context):
annotations = IAnnotations(context)
try:
result = annotations[key]
except KeyError:
result = factory()
annotations[key] = result
# Containment has to be set up late to allow containment
# proxies to be applied, if needed. This does not trigger
# an event and is idempotent if containment is set up
# already.
contained_result = contained(result, context, key)
return contained_result
component.provideAdapter(getAnnotation)
return True
def factory(self,
factory,
provides=None,
name=u'',
setup=None,
public=False,
name_in_container=None):
if provides is not None and not IInterface.providedBy(provides):
raise GrokImportError("You can only pass an interface to the "
"provides argument of %s." % self.name)
if provides is None:
# We cannot bind the provides directive and get information
# from the factory, so we do it "manually" as we know how
# to get to the information.
dotted = grokcore.component.provides.dotted_name()
provides = getattr(factory, dotted, None)
if provides is None:
if util.check_subclass(factory, LocalUtility):
baseInterfaces = interface.implementedBy(LocalUtility)
utilityInterfaces = interface.implementedBy(factory)
provides = list(utilityInterfaces - baseInterfaces)
if len(provides) == 0 and len(list(utilityInterfaces)) > 0:
raise GrokImportError(
"Cannot determine which interface to use "
"for utility registration of %r. "
"It implements an interface that is a specialization "
"of an interface implemented by grok.LocalUtility. "
"Specify the interface by either using grok.provides "
"on the utility or passing 'provides' to "
"grok.local_utility." % factory, factory)
else:
provides = list(interface.implementedBy(factory))
util.check_implements_one_from_list(provides, factory)
provides = provides[0]
if (provides, name) in self.frame.f_locals.get(self.dotted_name(), {}):
raise GrokImportError(
"Conflicting local utility registration %r. "
"Local utilities are registered multiple "
"times for interface %r and name %r." %
(factory, provides, name), factory)
info = LocalUtilityInfo(factory, provides, name, setup, public,
name_in_container)
return (provides, name), info
def factory(self, factory, provides=None, name=u'',
setup=None, public=False, name_in_container=None):
if provides is not None and not IInterface.providedBy(provides):
raise GrokImportError("You can only pass an interface to the "
"provides argument of %s." % self.name)
if provides is None:
# We cannot bind the provides directive and get information
# from the factory, so we do it "manually" as we know how
# to get to the information.
dotted = grokcore.component.provides.dotted_name()
provides = getattr(factory, dotted, None)
if provides is None:
if util.check_subclass(factory, LocalUtility):
baseInterfaces = interface.implementedBy(LocalUtility)
utilityInterfaces = interface.implementedBy(factory)
provides = list(utilityInterfaces - baseInterfaces)
if len(provides) == 0 and len(list(utilityInterfaces)) > 0:
raise GrokImportError(
"Cannot determine which interface to use "
"for utility registration of %r. "
"It implements an interface that is a specialization "
"of an interface implemented by grok.LocalUtility. "
"Specify the interface by either using grok.provides "
"on the utility or passing 'provides' to "
"grok.local_utility." % factory, factory)
else:
provides = list(interface.implementedBy(factory))
util.check_implements_one_from_list(provides, factory)
provides = provides[0]
if (provides, name) in self.frame.f_locals.get(self.dotted_name(), {}):
raise GrokImportError(
"Conflicting local utility registration %r. "
"Local utilities are registered multiple "
"times for interface %r and name %r." %
(factory, provides, name), factory)
info = LocalUtilityInfo(factory, provides, name, setup, public,
name_in_container)
return (provides, name), info
def grok(self, name, factory, context, module_info, templates):
infos = util.class_annotation_list(factory, 'grok.local_utility', None)
if infos is None:
return False
for info in infos:
if info.public and not IContainer.implementedBy(factory):
raise GrokError(
"Cannot set public to True with grok.local_utility as "
"the site (%r) is not a container." %
factory, factory)
if info.provides is None:
if util.check_subclass(info.factory, grok.LocalUtility):
baseInterfaces = interface.implementedBy(grok.LocalUtility)
utilityInterfaces = interface.implementedBy(info.factory)
provides = list(utilityInterfaces - baseInterfaces)
if len(provides) == 0 and len(list(utilityInterfaces)) > 0:
raise GrokError(
"Cannot determine which interface to use "
"for utility registration of %r in site %r. "
"It implements an interface that is a specialization "
"of an interface implemented by grok.LocalUtility. "
"Specify the interface by either using grok.provides "
"on the utility or passing 'provides' to "
"grok.local_utility." % (info.factory, factory),
info.factory)
else:
provides = list(interface.implementedBy(info.factory))
util.check_implements_one_from_list(provides, info.factory)
info.provides = provides[0]
# raise an error in case of any duplicate registrations
# on the class level (subclassing overrides, see below)
used = set()
class_infos = util.class_annotation(factory, 'grok.local_utility',
[])
for info in class_infos:
key = (info.provides, info.name)
if key in used:
raise GrokError(
"Conflicting local utility registration %r in "
"site %r. Local utilities are registered multiple "
"times for interface %r and name %r." %
(info.factory, factory, info.provides, info.name),
factory)
used.add(key)
# Make sure that local utilities from subclasses override
# utilities from base classes if the registration (provided
# interface, name) is identical.
overridden_infos = []
used = set()
for info in reversed(infos):
key = (info.provides, info.name)
if key in used:
continue
used.add(key)
overridden_infos.append(info)
overridden_infos.reverse()
# store infos on site class
factory.__grok_utilities_to_install__ = overridden_infos
component.provideHandler(localUtilityRegistrationSubscriber,
adapts=(factory, grok.IObjectAddedEvent))
return True
def default_annotation_provides(factory, module, **data):
base_interfaces = interface.implementedBy(grokcore.annotation.Annotation)
factory_interfaces = interface.implementedBy(factory)
real_interfaces = list(factory_interfaces - base_interfaces)
util.check_implements_one_from_list(real_interfaces, factory)
return real_interfaces[0]
def default_annotation_provides(factory, module, **data):
base_interfaces = interface.implementedBy(grokcore.annotation.Annotation)
factory_interfaces = interface.implementedBy(factory)
real_interfaces = list(factory_interfaces - base_interfaces)
util.check_implements_one_from_list(real_interfaces, factory)
return real_interfaces[0]
