def __get__(self, inst, cls=None):
global generated
if inst is None:
return getObjectSpecification(cls)
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
signature = getattr(inst, 'signature', None)
if signature is None:
return spec
if not ismd5hex(signature):
if not isdottedname(signature):
return spec
# not an md5 signature, so perhaps we have a dotted name
try:
iface = resolve(signature)
if not IInterface.providedBy(iface):
raise ValueError('Not interface: %s' % signature)
return Implements(iface, spec)
except ImportError:
logger.warning('SignatureAwareDescriptor: '
'unabled to resolve interface '
'%s by dotted name.')
return spec
iface_name = 'I%s' % signature
dynamic = [getattr(generated, iface_name)]
dynamic.append(spec)
spec = Implements(*dynamic)
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
provided = providedBy(inst._IndexableObjectWrapper__ob)
cls = type(inst)
return ObjectSpecification(provided, cls)
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the cached value.
cache = getattr(inst, "_v__providedBy__", None)
# Find the data we need to know if our cache needs to be invalidated
provided = link_provides = getattr(inst._context, "__provides__", None)
# See if we have a valid cache, and if so return it
if cache is not None:
cached_mtime, cached_provides, cached_provided = cache
if inst._p_mtime == cached_mtime and link_provides is cached_provides:
return cached_provided
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if provided is None:
provided = implementedBy(cls)
# Add the interfaces provided by the target, but ensure that some problematic
# interfaces are removed
provided += providedBy(
inst._context) - IIterateAware - IVersioningSupport
provided += ISymlinkMarker
inst._v__providedBy__ = inst._p_mtime, link_provides, provided
return provided
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
obj = inst._IndexableObjectWrapper__ob
provided = providedBy(obj)
return Provides(type(obj), implementedBy(cls), provided)
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the data we need to know if our cache needs to be invalidated
direct_spec = getattr(inst, '__provides__', None)
# If the draft proxy doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if direct_spec is None:
direct_spec = implementedBy(cls)
# Get the interfaces provided by the target
target = aq_base(inst.__dict__.get('_DraftProxy__target'))
if target is None:
return direct_spec
target_spec = providedBy(target)
# Find the cached value
cache = inst.__dict__.get('_DraftProxy__providedBy__', None)
updated = target._p_mtime, direct_spec, target_spec
# See if we have a valid cache. Reasons to do this include:
if cache is not None:
cached_mtime, cached_direct_spec, \
cached_target_spec, cached_spec = cache
if cache[:-1] == updated:
return cached_spec
spec = direct_spec + target_spec
inst.__dict__['_DraftProxy__providedBy__'] = updated + (spec,)
return spec
def __get__(self, inst, cls=None):
global generated
if inst is None:
return getObjectSpecification(cls)
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
signature = getattr(inst, 'signature', None)
if signature is None:
return spec
if not ismd5hex(signature):
if not isdottedname(signature):
return spec
# not an md5 signature, so perhaps we have a dotted name
try:
iface = resolve(signature)
if not IInterface.providedBy(iface):
raise ValueError('Not interface: %s' % signature)
return Implements(iface, spec)
except ImportError:
logger.warning('SignatureAwareDescriptor: '
'unabled to resolve interface '
'%s by dotted name.')
return spec
iface_name = 'I%s' % signature
dynamic = [getattr(generated, iface_name)]
dynamic.append(spec)
spec = Implements(*dynamic)
return spec
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the data we need to know if our cache needs to be invalidated
direct_spec = getattr(inst, '__provides__', None)
# If the draft proxy doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if direct_spec is None:
direct_spec = implementedBy(cls)
# Get the interfaces provided by the target
target = aq_base(inst.__dict__.get('_DraftProxy__target'))
if target is None:
return direct_spec
target_spec = providedBy(target)
# Find the cached value
cache = inst.__dict__.get('_DraftProxy__providedBy__', None)
updated = target._p_mtime, direct_spec, target_spec
# See if we have a valid cache. Reasons to do this include:
if cache is not None:
cached_mtime, cached_direct_spec, \
cached_target_spec, cached_spec = cache
if cache[:-1] == updated:
return cached_spec
spec = direct_spec + target_spec
inst.__dict__['_DraftProxy__providedBy__'] = updated + (spec, )
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
provided = providedBy(inst._IndexableObjectWrapper__ob)
cls = type(inst)
return ObjectSpecification(provided, cls)
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the cached value and return it if possible
cached = getattr(inst, '_v__providedBy__', None)
if cached is not None:
return cached
# Get interfaces directly provided by the draft proxy
provided = getattr(inst, '__provides__', None)
# If the draft proxy doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if provided is None:
provided = implementedBy(cls)
# Add the interfaces provided by the target
target = aq_base(inst._DraftProxy__target)
if target is None:
return provided
provided += providedBy(target)
inst._v__providedBy__ = provided
return provided
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
tp = inst.__type__
cached = getattr(tp, '_v__providedBy', _marker)
if cached is not _marker:
return cached
provided = [implementedBy(inst.__class__)]
bhreg = AdapterRegistry()
for behavior in tp.behaviors:
behavior = queryBehavior(behavior)
if behavior is not None:
bhreg.register((), behavior.spec, '', behavior)
provided.append(behavior.spec)
schreg = AdapterRegistry()
for schId in tp.schemas:
sch = querySchema(schId)
if sch is not None and sch.spec not in provided:
schreg.register((), sch.spec, '', sch)
provided.append(sch.spec)
spec = Implements(*provided)
tp._v__providedBy = spec
tp._v__bhCache = bhreg
tp._v__schCache = schreg
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
obj = inst._IndexableObjectWrapper__ob
provided = providedBy(obj)
return Provides(
type(obj), implementedBy(cls), provided)
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the data we need to know if our cache needs to be invalidated
direct_spec = getattr(inst, '__provides__', None)
portal_type = getattr(inst, 'portal_type', None)
spec = direct_spec
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if spec is None:
spec = implementedBy(cls)
# If the instance has no portal type, then we're done.
if portal_type is None:
return spec
fti = queryUtility(IDexterityFTI, name=portal_type)
if fti is None:
return spec
schema = SCHEMA_CACHE.get(portal_type)
subtypes = SCHEMA_CACHE.subtypes(portal_type)
# Find the cached value. This calculation is expensive and called
# hundreds of times during each request, so we require a fast cache
cache = getattr(inst, '_v__providedBy__', None)
updated = inst._p_mtime, schema, subtypes, direct_spec
# See if we have a valid cache. Reasons to do this include:
#
# - The schema was modified.
# - The subtypes were modified.
# - The instance was modified and persisted since the cache was built.
# - The instance has a different direct specification.
if cache is not None:
cached_mtime, cached_schema, cached_subtypes, \
cached_direct_spec, cached_spec = cache
if cache[:-1] == updated:
return cached_spec
dynamically_provided = [] if schema is None else [schema]
dynamically_provided.extend(subtypes)
# If we have neither a schema, nor a subtype, then we're also done.
if not dynamically_provided:
return spec
dynamically_provided.append(spec)
spec = Implements(*dynamically_provided)
inst._v__providedBy__ = updated + (spec, )
return spec
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the data we need to know if our cache needs to be invalidated
direct_spec = getattr(inst, '__provides__', None)
portal_type = getattr(inst, 'portal_type', None)
spec = direct_spec
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if spec is None:
spec = implementedBy(cls)
# If the instance has no portal type, then we're done.
if portal_type is None:
return spec
fti = queryUtility(IDexterityFTI, name=portal_type)
if fti is None:
return spec
schema = SCHEMA_CACHE.get(portal_type)
subtypes = SCHEMA_CACHE.subtypes(portal_type)
# Find the cached value. This calculation is expensive and called
# hundreds of times during each request, so we require a fast cache
cache = getattr(inst, '_v__providedBy__', None)
updated = inst._p_mtime, schema, subtypes, direct_spec
# See if we have a valid cache. Reasons to do this include:
#
# - The schema was modified.
# - The subtypes were modified.
# - The instance was modified and persisted since the cache was built.
# - The instance has a different direct specification.
if cache is not None:
cached_mtime, cached_schema, cached_subtypes, \
cached_direct_spec, cached_spec = cache
if cache[:-1] == updated:
return cached_spec
dynamically_provided = [] if schema is None else [schema]
dynamically_provided.extend(subtypes)
# If we have neither a schema, nor a subtype, then we're also done.
if not dynamically_provided:
return spec
dynamically_provided.append(spec)
spec = Implements(*dynamically_provided)
inst._v__providedBy__ = updated + (spec, )
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
provided = providedBy(getProxiedObject(inst))
# Use type rather than __class__ because inst is a proxy and
# will return the proxied object's class.
cls = type(inst)
return ObjectSpecification(provided, cls)
def __get__(self, inst, cls=None):
if inst is None: # pragma: no cover (Not sure how we can get here)
return getObjectSpecification(cls)
provided = providedBy(getProxiedObject(inst))
# Use type rather than __class__ because inst is a proxy and
# will return the proxied object's class.
cls = type(inst)
return ObjectSpecification(provided, cls)
def __get__(self, inst, cls=None):
if inst is None: # pragma: no cover (Not sure how we can get here)
return getObjectSpecification(cls)
provided = providedBy(getProxiedObject(inst))
# Use type rather than __class__ because inst is a proxy and
# will return the proxied object's class.
cls = type(inst)
return ObjectSpecification(provided, cls)
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
provided = providedBy(getProxiedObject(inst))
# Use type rather than __class__ because inst is a proxy and
# will return the proxied object's class.
cls = type(inst)
return ObjectSpecification(provided, cls)
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
request = getRequest()
annotations = IAnnotations(request)
try:
digest = inst.schema_digest
except AttributeError:
spec = getattr(inst, '__provides__', None)
if spec is None:
return implementedBy(cls)
else:
return spec
# Return cached spec from request
if not getattr(self, '__recursion__', False):
spec = annotations.get(self.__class__.__name__ + '.' + digest)
if spec is not None:
return spec
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
model = load_model(inst.schema, cache_key=inst.schema_digest)
schemata = [
model.schemata[name] for name in model.schemata
if name in [u'', u'++add++']
or IS_TRANSLATION.match(name.split(u'++add++')[0])
]
schemata.append(spec)
if getattr(self, '__recursion__', False):
return Implements(*schemata)
self.__recursion__ = True
dynamically_provided = []
try:
assignable = IBehaviorAssignable(inst, None)
if assignable is not None:
for behavior_registration in assignable.enumerateBehaviors():
if behavior_registration.marker:
dynamically_provided.append(
behavior_registration.marker, )
finally:
del self.__recursion__
schemata.extend(dynamically_provided)
spec = Implements(*schemata)
# Cache spec into request
annotations[self.__class__.__name__ + '.' + digest] = spec
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
request = getRequest()
annotations = IAnnotations(request)
# Return cached spec from request
if inst.__parent__ is not None and inst.__name__ is not None:
digest = inst.__parent__.schema_digest
key = '.'.join([self.__class__.__name__, digest, inst.__name__])
spec = annotations.get(key)
if spec is not None:
return spec
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
model = load_model(
aq_base(inst.__parent__).schema,
cache_key=inst.__parent__.schema_digest,
)
schemata = []
for schema in [
model.schemata[name] for name in model.schemata
if name == u'' or IS_TRANSLATION.match(name)
]:
try:
field = schema[inst.__name__]
except AttributeError:
continue
try:
schemata.append(field.schema)
except AttributeError:
schemata.append(field.value_type.schema)
schemata.append(spec)
spec = Implements(*schemata)
# Cache spec into request
annotations[key] = spec
else:
spec = getattr(inst, '__provides__', None)
if spec is None:
spec = implementedBy(cls)
# Set by FlowSubmissionDataFactory
schemata = [inst._v_initial_schema, spec]
spec = Implements(*schemata)
return spec
def __get__(self, inst, cls=None):
if inst is None: # pragma: no cover (Not sure how we can get here)
return getObjectSpecification(cls)
provided = providedBy(getProxiedObject(inst))
# Use type rather than __class__ because inst is a proxy and
# will return the proxied object's class.
cls = type(inst)
implemented_by_cls = implementedBy(cls)
for iface in list(provided):
if implemented_by_cls.isOrExtends(iface):
provided = provided - iface
return Provides(cls, provided)
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the cached value.
cache = getattr(inst, '_v__providedBy__', None)
# Find the data we need to know if our cache needs to be invalidated
provided = alias_provides = getattr(inst, '__provides__', None)
# See if we have a valid cache, and if so return it
if cache is not None:
cached_mtime, cached_provides, cached_provided = cache
if (
inst._p_mtime == cached_mtime and
alias_provides is cached_provides
):
return cached_provided
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if provided is None:
assert cls == Alias # XXX: remove
provided = implementedBy(cls)
# Add the interfaces provided by the target
target = aq_base(inst._target)
if target is None:
return provided # don't cache yet!
# Add the interfaces provided by the target, but take away
# IHasAlias if set
provided += providedBy(target) - IHasAlias - IIterateAware
if ITranslatable:
provided -= ITranslatable
inst._v__providedBy__ = inst._p_mtime, alias_provides, provided
return provided
def applyChanges(self, changes):
names = []
ispec = list(getObjectSpecification(self).interfaces())[0]
for field, value in changes.items():
if value is not None:
setattr(self, field, value)
names.append(field)
if names:
if ispec:
description = [zope.lifecycleevent.Attributes(ispec, *names)]
# Send out a detailed object-modified event
zope.event.notify(
zope.lifecycleevent.ObjectModifiedEvent(
self, *description))
if hasattr(self, 'postApply'):
self.postApply(changes)
self.put()
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the cached value.
cache = getattr(inst, '_v__providedBy__', None)
# Find the data we need to know if our cache needs to be invalidated
provided = alias_provides = getattr(inst, '__provides__', None)
# See if we have a valid cache, and if so return it
if cache is not None:
cached_mtime, cached_provides, cached_provided = cache
if (inst._p_mtime == cached_mtime
and alias_provides is cached_provides):
return cached_provided
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if provided is None:
assert cls == Alias # XXX: remove
provided = implementedBy(cls)
# Add the interfaces provided by the target
target = aq_base(inst._target)
if target is None:
return provided # don't cache yet!
# Add the interfaces provided by the target, but take away
# IHasAlias if set
provided += providedBy(target) - IHasAlias - IIterateAware
if ITranslatable:
provided -= ITranslatable
inst._v__providedBy__ = inst._p_mtime, alias_provides, provided
return provided
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the cached value. This calculation is expensive and called
# hundreds of times during each request, so we require a fast cache
cache = getattr(inst, '_v__providedBy__', None)
# Find the data we need to know if our cache needs to be invalidated
direct_spec = getattr(inst, '__provides__', None)
portal_type = getattr(inst, 'portal_type', None)
fti_counter = -1
if portal_type is not None:
fti_counter = SCHEMA_CACHE.counter(portal_type)
# See if we have a valid cache. Reasons to do this include:
#
# - We don't have a portal_type yet, so we can't have found the schema
# - The FTI was modified, and the schema cache invalidated globally.
# The fti_counter will have advanced.
# - The instance was modified and persisted since the cache was built.
# - The instance now has a different __provides__, which means that someone
# called directlyProvides/alsoProvides on it.
if cache is not None and portal_type is not None:
cached_mtime, cached_fti_counter, cached_direct_spec, cached_spec = cache
if inst._p_mtime == cached_mtime and \
fti_counter == cached_fti_counter and \
direct_spec is cached_direct_spec:
return cached_spec
# We don't have a cache, so we need to build a new spec and maybe cache it
spec = direct_spec
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if spec is None:
spec = implementedBy(cls)
# Add the schema from the FTI and behavior subtypes
dynamically_provided = []
if portal_type is not None:
schema = SCHEMA_CACHE.get(portal_type)
if schema is not None:
dynamically_provided.append(schema)
subtypes = SCHEMA_CACHE.subtypes(portal_type)
if subtypes:
dynamically_provided.extend(subtypes)
# If we have any dynamically provided interface, prepend them to the spec
# and cache. We can't cache until we have at least the schema, because
# it's possible that we were called before traversal and so could not
# find the schema yet.
if dynamically_provided:
dynamically_provided.append(spec)
spec = Implements(*dynamically_provided)
inst._v__providedBy__ = inst._p_mtime, SCHEMA_CACHE.counter(
portal_type), direct_spec, spec
return spec
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
direct_spec = getattr(inst, '__provides__', None)
# avoid recursion - fall back on default
if getattr(self, '__recursion__', False):
return direct_spec
spec = direct_spec
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if spec is None:
spec = implementedBy(cls)
# Find the data we need to know if our cache needs to be invalidated
portal_type = getattr(inst, 'portal_type', None)
# If the instance has no portal type, then we're done.
if portal_type is None:
return spec
# Find the cached value. This calculation is expensive and called
# hundreds of times during each request, so we require a fast cache
cache = getattr(inst, '_v__providedBy__', None)
# See if we have a current cache. Reasons to do this include:
#
# - The FTI was modified.
# - The instance was modified and persisted since the cache was built.
# - The instance has a different direct specification.
updated = (inst._p_mtime, SCHEMA_CACHE.modified(portal_type),
SCHEMA_CACHE.invalidations, hash(direct_spec))
if cache is not None and cache[:-1] == updated:
if cache[-1] is not None:
return cache[-1]
return spec
main_schema = SCHEMA_CACHE.get(portal_type)
if main_schema:
dynamically_provided = [main_schema]
else:
dynamically_provided = []
# block recursion
self.__recursion__ = True
try:
assignable = IBehaviorAssignable(inst, None)
if assignable is not None:
for behavior_registration in assignable.enumerateBehaviors():
if behavior_registration.marker:
dynamically_provided.append(
behavior_registration.marker)
finally:
del self.__recursion__
if not dynamically_provided:
# rare case if no schema nor behaviors with markers are set
inst._v__providedBy__ = updated + (None, )
return spec
dynamically_provided.append(spec)
all_spec = Implements(*dynamically_provided)
inst._v__providedBy__ = updated + (all_spec, )
return all_spec
def __get__(self, inst, cls=None): # noqa
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
direct_spec = getattr(inst, '__provides__', None)
# avoid recursion - fall back on default
if getattr(self, '__recursion__', False):
return direct_spec
spec = direct_spec
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if spec is None:
spec = implementedBy(cls)
# Find the data we need to know if our cache needs to be invalidated
portal_type = getattr(inst, 'portal_type', None)
# If the instance has no portal type, then we're done.
if portal_type is None:
return spec
# Find the cached value. This calculation is expensive and called
# hundreds of times during each request, so we require a fast cache
cache = getattr(inst, '_v__providedBy__', None)
# See if we have a current cache. Reasons to do this include:
#
# - The FTI was modified.
# - The instance was modified and persisted since the cache was built.
# - The instance has a different direct specification.
updated = (
inst._p_mtime,
SCHEMA_CACHE.modified(portal_type),
SCHEMA_CACHE.invalidations,
hash(direct_spec)
)
if cache is not None and cache[:-1] == updated:
if cache[-1] is not None:
return cache[-1]
return spec
main_schema = SCHEMA_CACHE.get(portal_type)
if main_schema:
dynamically_provided = [main_schema]
else:
dynamically_provided = []
# block recursion
self.__recursion__ = True
try:
assignable = IBehaviorAssignable(inst, None)
if assignable is not None:
for behavior_registration in assignable.enumerateBehaviors():
if behavior_registration.marker:
dynamically_provided.append(
behavior_registration.marker
)
finally:
del self.__recursion__
if not dynamically_provided:
# rare case if no schema nor behaviors with markers are set
inst._v__providedBy__ = updated + (None, )
return spec
dynamically_provided.append(spec)
all_spec = Implements(*dynamically_provided)
inst._v__providedBy__ = updated + (all_spec, )
return all_spec
def __get__(self, inst, cls=None):
# We're looking at a class - fall back on default
if inst is None:
return getObjectSpecification(cls)
# Find the cached value. This calculation is expensive and called
# hundreds of times during each request, so we require a fast cache
cache = getattr(inst, '_v__providedBy__', None)
# Find the data we need to know if our cache needs to be invalidated
direct_spec = getattr(inst, '__provides__', None)
portal_type = getattr(inst, 'portal_type', None)
fti_counter = -1
if portal_type is not None:
fti_counter = SCHEMA_CACHE.counter(portal_type)
# See if we have a valid cache. Reasons to do this include:
#
# - We don't have a portal_type yet, so we can't have found the schema
# - The FTI was modified, and the schema cache invalidated globally.
# The fti_counter will have advanced.
# - The instance was modified and persisted since the cache was built.
# - The instance now has a different __provides__, which means that someone
# called directlyProvides/alsoProvides on it.
if cache is not None and portal_type is not None:
cached_mtime, cached_fti_counter, cached_direct_spec, cached_spec = cache
if inst._p_mtime == cached_mtime and \
fti_counter == cached_fti_counter and \
direct_spec is cached_direct_spec:
return cached_spec
# We don't have a cache, so we need to build a new spec and maybe cache it
spec = direct_spec
# If the instance doesn't have a __provides__ attribute, get the
# interfaces implied by the class as a starting point.
if spec is None:
spec = implementedBy(cls)
# Add the schema from the FTI and behavior subtypes
dynamically_provided = []
if portal_type is not None:
schema = SCHEMA_CACHE.get(portal_type)
if schema is not None:
dynamically_provided.append(schema)
subtypes = SCHEMA_CACHE.subtypes(portal_type)
if subtypes:
dynamically_provided.extend(subtypes)
# If we have any dynamically provided interface, prepend them to the spec
# and cache. We can't cache until we have at least the schema, because
# it's possible that we were called before traversal and so could not
# find the schema yet.
if dynamically_provided:
dynamically_provided.append(spec)
spec = Implements(*dynamically_provided)
inst._v__providedBy__ = inst._p_mtime, SCHEMA_CACHE.counter(portal_type), direct_spec, spec
return spec
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
return inst.__provides__
def __get__(self, inst, cls=None):
if inst is None:
return getObjectSpecification(cls)
else:
return inst.__provides__
