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()

 def _get_post_metric_name(self, iresource: IInterface) -> str:
     name = 'process.post'
     if iresource.isOrExtends(IProposalVersion):
         name = 'process.post.proposalversion'
     elif iresource.isOrExtends(IRateVersion):
         name = 'process.post.rateversion'
     return name

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)

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

    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

 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))
     )

 def __init__(self, context, schema):
     if not IComposedQuery.providedBy(context):
         raise ValueError('context must provide IComposedQuery')
     if not IInterface.providedBy(schema):
         raise ValueError('schema provided must be interface')
     self.context = context
     self.schema = schema

def referential_integrity(event):
    if event.moving is not None: # being moved
        return

    objectmap = find_objectmap(event.object)

    if objectmap is None:
        return

    reftypes = list(objectmap.get_reftypes())

    for oid in event.removed_oids:

        for reftype in reftypes:

            is_iface = IInterface.providedBy(reftype)

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

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

 def _validate(self, value):
     super(InterfaceField, self)._validate(value)
     if not IInterface.providedBy(value):
         raise NotAnInterface(
             value,
             self.__name__
         ).with_field_and_value(self, value)

 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 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
     

    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)

def resolve(name):
    """Resolve the name.
    """
    obj = pythonResolve(name)
    if not IInterface.providedBy(obj):
        return obj.__provides__._implements
    return obj

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__

 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)

 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)

    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)

 def __init__(self, context, request):
     super(ModuleDetails, self).__init__(context, request)
     items = list(self.context.items())
     items.sort()
     self.text_files = []
     self.zcml_files = []
     self.modules = []
     self.interfaces = []
     self.classes = []
     self.functions = []
     for name, obj in items:
         entry = {'name': name, 'url': absoluteURL(obj, self.request)}
         if IFunctionDocumentation.providedBy(obj):
             entry['doc'] = formatDocString(
                 obj.getDocString(), self.context.getPath())
             entry['signature'] = obj.getSignature()
             self.functions.append(entry)
         elif IModuleDocumentation.providedBy(obj):
             entry['doc'] = formatDocString(
                 obj.getDocString(), obj.getPath(), True)
             self.modules.append(entry)
         elif IInterface.providedBy(obj):
             entry['path'] = getPythonPath(removeAllProxies(obj))
             entry['doc'] = formatDocString(
                 obj.__doc__, obj.__module__, True)
             self.interfaces.append(entry)
         elif IClassDocumentation.providedBy(obj):
             entry['doc'] = formatDocString(
                 obj.getDocString(), self.context.getPath(), True)
             self.classes.append(entry)
         elif IZCMLFile.providedBy(obj):
             self.zcml_files.append(entry)
         elif ITextFile.providedBy(obj):
             self.text_files.append(entry)

def MultiChecker(specs):
    """Create a checker from a sequence of specifications

    A specification is:

    - A two-tuple with:

      o a sequence of names or an interface

      o a permission id

      All the names in the sequence of names or the interface are
      protected by the permission.

    - A dictionoid (having an items method), with items that are
      name/permission-id pairs.
    """
    data = {}

    for spec in specs:
        if type(spec) is tuple:
            names, permission_id = spec
            if IInterface.providedBy(names):
                names = names.names(all=True)
            for name in names:
                if data.get(name, permission_id) is not permission_id:
                    raise DuplicationError(name)
                data[name] = permission_id
        else:
            for name, permission_id in spec.items():
                if data.get(name, permission_id) is not permission_id:
                    raise DuplicationError(name)
                data[name] = permission_id

    return Checker(data)

    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)