Python IInterface.providedBy方法代码示例

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 def manage_FTPget(self, REQUEST=None, RESPONSE=None):
     """Return the body of the content item in an FTP or WebDAV response.
     
     This adapts self to IRawReadFile(), which is then returned as an
     iterator. The adapter should provide IStreamIterator.
     """
     reader = IRawReadFile(self, None)
     if reader is None:
         return ''
     
     request = REQUEST is not None and REQUEST or self.REQUEST
     response = RESPONSE is not None and RESPONSE or request.response
     
     mimeType = reader.mimeType
     encoding = reader.encoding
     
     if mimeType is not None:
         if encoding is not None:
             response.setHeader('Content-Type', '%s; charset="%s"' % (mimeType, encoding,))
         else:
             response.setHeader('Content-Type', mimeType)
     
     size = reader.size()
     if size is not None:
         response.setHeader('Content-Length', str(size))
     
     # if the reader is an iterator that the publisher can handle, return
     # it as-is. Otherwise, read the full contents
     
     if ((IInterface.providedBy(IStreamIterator) and IStreamIterator.providedBy(reader))
      or (not IInterface.providedBy(IStreamIterator) and IStreamIterator.isImplementedBy(reader))
     ):
         return reader
     else:
         return reader.read()

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
def find_parents(context, findone=False, start_depth=2, **kwargs):
    typename = kwargs.get("typename", None)
    iface = kwargs.get("iface", None)
    if IInterface.providedBy(iface):
        iface = iface.__identifier__
    if findone and typename is None and iface is None:
        parent = getattr(context, "__parent__", None)
        if parent:
            return parent  # immediate parent of context
    result = []
    catalog = getToolByName(context, "portal_catalog")
    path = context.getPhysicalPath()
    subpaths = reversed([path[0:i] for i in range(len(path) + 1)][start_depth:])
    for subpath in subpaths:
        query = {"path": {"query": "/".join(subpath), "depth": 0}}
        if typename is not None:
            query["portal_type"] = typename
        if iface is not None:
            query["object_provides"] = iface
        brains = catalog.unrestrictedSearchResults(query)
        if not brains:
            continue
        else:
            item = brains[0]._unrestrictedGetObject()
            if aq_base(item) is aq_base(context):
                continue  # don't return or append the context itself!
            if findone:
                return item
            result.append(item)
    if findone:
        return None  # never found one
    return result

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
def referential_integrity(event):
    if event.moving:
        return
    obj = event.object
    obj_oid = oid_of(obj, None)
    objectmap = find_objectmap(obj)
    if objectmap is None:
        return
    for reftype in objectmap.get_reftypes():

        is_iface = IInterface.providedBy(reftype)

        if is_iface and reftype.queryTaggedValue('source_integrity', False):
            targetids = objectmap.targetids(obj, reftype)
            if obj_oid in targetids:
                targetids.remove(obj_oid) # self-referential
            if targetids:
                # object is a source
                raise SourceIntegrityError(obj, reftype, targetids)

        if is_iface and reftype.queryTaggedValue('target_integrity', False):
            sourceids = objectmap.sourceids(obj, reftype)
            if obj_oid in sourceids:
                sourceids.remove(obj_oid) # self-referential
            if sourceids:
                # object is a target
                raise TargetIntegrityError(obj, reftype, sourceids)

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
    def resolve_isheet_field_from_dotted_string(self, dotted: str) -> tuple:
        """Resolve `dotted` string to isheet and field name and schema node.

        :dotted: isheet.__identifier__ and field_name separated by ':'
        :return: tuple with isheet (ISheet), field_name (str), field schema
                 node (colander.SchemaNode).
        :raise ValueError: If the string is not dotted or it cannot be
            resolved to isheet and field name.
        """
        if ':' not in dotted:
            raise ValueError(
                'Not a colon-separated dotted string: {}'.format(dotted))
        name = ''.join(dotted.split(':')[:-1])
        field = dotted.split(':')[-1]
        try:
            isheet = resolver.resolve(name)
        except ImportError:
            raise ValueError('No such sheet: {}'.format(name))
        if not (IInterface.providedBy(isheet) and isheet.isOrExtends(ISheet)):
            raise ValueError('Not a sheet: {}'.format(name))
        schema = self.sheets_meta[isheet].schema_class()
        node = schema.get(field, None)
        if not node:
            raise ValueError('No such field: {}'.format(dotted))
        return isheet, field, node

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 def available(self):
     # We are available if we have sublevel menu or a screen.
     return (
         (len(self.submenu) != 0)
         or IUIScreen.implementedBy(self.screen)
         or (IInterface.providedBy(self.interface) and self.interface.extends(IUIScreen))
     )

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
    def setup(self, catalog, name, context, module_info):
        # If the user supplied attribute= when instantiating us, we
        # allow that value to override the attribute name under which we
        # are actually stored inside of the `grokcore.catalog.Indexes`
        # instance.
        if self._attribute is not None:
            field_name = self._attribute
        else:
            field_name = name

        if IInterface.providedBy(context):
            try:
                method = context[field_name]
            except KeyError:
                raise GrokError(
                    "grokcore.catalog.Indexes in %r refers to an attribute or "
                    "method %r on interface %r, but this does not "
                    "exist." % (module_info.getModule(),
                                field_name, context), None)
            call = IMethod.providedBy(method)
        else:
            call = callable(getattr(context, field_name, None))
            context = None  # no interface lookup
        catalog[name] = self.index_class(
            field_name=field_name,
            interface=context,
            field_callable=call,
            *self._args, **self._kw)

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 def bind(self, schema):
     if not IInterface.providedBy(schema):
         raise TypeError("Cannot bind non-interface object %s" % schema)
     name = identify_interface(schema)
     if name in self._names:
         raise KeyError("duplicate schema: Interface %s already managed." % (name,))
     self._names.append(name)

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 def __init__(self, context, schema):
     if not IFilterGroup.providedBy(context):
         raise ValueError('context must provide IFilterGroup')
     if not IInterface.providedBy(schema):
         raise ValueError('schema provided must be interface')
     self.context = context
     self.schema = schema

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 def forget(self, schema):
     name = str(schema)
     if IInterface.providedBy(schema):
         name = identify_interface(schema)
     if name not in self._names:
         return
     self._names.remove(name)

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
    def register(template=template):
        if isinstance(template, basestring):
            helper = renderers.RendererHelper(name=template, package=config.package, registry=config.registry)
            template = helper.renderer.implementation()

        layout_intr.update(dict(name=name, filename=template.filename, context=context, callable=layout))
        introspectables.append(layout_intr)

        def derived_layout(context, request):
            wrapped = layout(context, request)
            wrapped.__layout__ = name
            wrapped.__template__ = template
            return wrapped

        r_context = context
        if r_context is None:
            r_context = Interface
        if not IInterface.providedBy(r_context):
            r_context = implementedBy(r_context)

        reg_layout = config.registry.adapters.lookup((r_context,), ILayout, name=name)
        if isinstance(reg_layout, _MultiLayout):
            reg_layout[containment] = derived_layout
            return
        elif containment:
            reg_layout = _MultiLayout(reg_layout)
            reg_layout[containment] = derived_layout
        else:
            reg_layout = derived_layout

        config.registry.registerAdapter(reg_layout, (context,), ILayout, name=name)

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 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

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
 def factory(self, schema):
     if not IInterface.providedBy(schema):
         raise GrokImportError(
             "You can only pass an interface to the "
             "provides argument of %s." % self.name)
     return schema
     

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
def resolve(name):
    """Resolve the name.
    """
    obj = pythonResolve(name)
    if not IInterface.providedBy(obj):
        return obj.__provides__._implements
    return obj

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
def identifier(obj):
    """Gives the Python identifier for the given object, so after we
    can do resolve on it to get it back.
    """
    if IInterface.providedBy(obj):
        return obj.__identifier__
    return obj.__name__

# 需要导入模块: from zope.interface.interfaces import IInterface [as 别名]
# 或者: from zope.interface.interfaces.IInterface import providedBy [as 别名]
    def __init__(self, schema=_NotGiven, **kw):
        """
        Object(schema=<Not Given>, *, validate_invariants=True, **kwargs)

        Create an `~.IObject` field. The keyword arguments are as for `~.Field`.

        .. versionchanged:: 4.6.0
           Add the keyword argument *validate_invariants*. When true (the default),
           the schema's ``validateInvariants`` method will be invoked to check
           the ``@invariant`` properties of the schema.
        .. versionchanged:: 4.6.0
           The *schema* argument can be ommitted in a subclass
           that specifies a ``schema`` attribute.
        """
        if schema is _NotGiven:
            schema = self.schema

        if not IInterface.providedBy(schema):
            # Note that we don't provide 'self' as the 'field'
            # by calling with_field_and_value(): We're not fully constructed,
            # we don't want this instance to escape.
            raise NotAnInterface(schema, self.__name__)

        self.schema = schema
        self.validate_invariants = kw.pop('validate_invariants', True)
        super(Object, self).__init__(**kw)