def getParentsFromContextToObject(context, obj):
    """Returns a list starting with the given context's parent followed by
    each of its parents till we reach the object.

    If the child object is not a child of the parent a empty list
    will return.
    """
    # this is a very bad situation. The context could be a NotFound error.
    # Such NotFound objects provide a LocationProxy with the site as parent
    # even if we don't allow the site in our possible parent chain. So skip it.
    if zope.publisher.interfaces.INotFound.providedBy(context):
        return []

    if not isChildOf(context, obj):
        return []
    
    if sameProxiedObjects(context, obj):
        return []

    parents = []
    w = context

    while 1:
        w = w.__parent__
        if sameProxiedObjects(w, obj):
            parents.append(w)
            break
        if w is None:
            break
        
        parents.append(w)

    return parents

    def start_imap_service(self):
        """
        Starts imap service.
        """
        from leap.bitmask.config import flags

        logger.debug('Starting imap service')
        leap_assert(sameProxiedObjects(self._soledad, None)
                    is not True,
                    "We need a non-null soledad for initializing imap service")
        leap_assert(sameProxiedObjects(self._keymanager, None)
                    is not True,
                    "We need a non-null keymanager for initializing imap "
                    "service")

        offline = flags.OFFLINE
        self.imap_service, self.imap_port, \
            self.imap_factory = imap.start_imap_service(
                self._soledad,
                self._keymanager,
                userid=self.userid,
                offline=offline)

        if offline is False:
            logger.debug("Starting loop")
            self.imap_service.start_loop()

 def renderCells(self, schedule, day, item):
     if sameProxiedObjects(schedule, self.context.periods):
         period = item
         return (period.title,
                 self.activityTitle(period.activity_type) or '')
     if sameProxiedObjects(schedule, self.context.time_slots):
         slot = item
         return (format_time_range(slot.tstart, slot.duration),
                 self.activityTitle(slot.activity_type) or '')
     return None

def contained(obj, parent=None, name=None):
    """An implementation of zope.app.container.contained.contained
    that doesn't generate events, for internal use.

    copied from SQLOS / z3c.zalchemy
    """
    if (parent is None):
        raise TypeError('Must provide a parent')

    if not IContained.providedBy(obj):
        if ILocation.providedBy(obj):
            interface.directlyProvides(obj, IContained,
                                       interface.directlyProvidedBy(obj))
        else:
            obj = ContainedProxy(obj)

    oldparent = obj.__parent__
    oldname = obj.__name__

    if (oldparent is None) or not (oldparent is parent
                                   or sameProxiedObjects(oldparent, parent)):
        obj.__parent__ = parent

    if oldname != name and name is not None:
        obj.__name__ = name

    return obj

    def breadcrumbs(self):
        context = self.context
        request = self.request

        # We do this here do maintain the rule that we must be wrapped
        context = ILocation(context, context)
        container = getattr(context, '__parent__', None)
        if container is None:
            raise TypeError(_insufficientContext)

        if sameProxiedObjects(context, request.getVirtualHostRoot()) or \
               isinstance(context, Exception):
            return ({'name':'', 'url': self.request.getApplicationURL()}, )

        base = tuple(zope.component.getMultiAdapter(
                (container, request), IAbsoluteURL).breadcrumbs())

        name = getattr(context, '__name__', None)
        if name is None:
            raise TypeError(_insufficientContext)

        if name:
            base += ({'name': name,
                      'url': ("%s/%s" % (base[-1]['url'],
                                         urllib.quote(name.encode('utf-8'),
                                                      _safe)))
                      }, )

        return base

 def add_container_menu_items(self, context, container):
     request = self.request
     
     _url = url.absoluteURL(container, request)
     
     if IReadContainer.providedBy(container):
         #XXX should be the same in all containers ?
         container=proxy.removeSecurityProxy(container)
         for name, item in container.items():
             if context is None:
                 selected = False
             else:
                 selected = url.same_path_names(context.__name__, name)
             item = proxy.removeSecurityProxy(item)
             if IDCDescriptiveProperties.providedBy(item):
                 title = item.title
             else:
                 props = IDCDescriptiveProperties(item)
                 title = props.title
             # only items with valid title
             if title is not None:
                 self.items.append(url.get_menu_item_descriptor(
                         title, selected, _url, name))
     default_view_name = queryDefaultViewName(container, self.request)
     default_view = component.queryMultiAdapter(
         (container, self.request), name=default_view_name)
     if hasattr(default_view, "title") and default_view.title is not None:
         self.items.insert(0, url.get_menu_item_descriptor(
                 default_view.title, 
                 sameProxiedObjects(container, self.context), 
                 _url))

 def __str__(self):
     target = removeSecurityProxy(self.context).__target__
     vhostroot = self.request.getVirtualHostRoot()
     if sameProxiedObjects(vhostroot, target):
         return str(AbsoluteURL(target, self.request))
     log.debug("ProxyAwareAbsoluteURL.__str__: %s [%s]", vhostroot, target)
     return super(ProxyAwareAbsoluteURL, self).__str__()

    def upperContainer(self):
        request = self.request
        vhr = request.getVirtualHostRoot()
        parent = getattr(self.context, '__parent__', None)

        while True:
            if (parent is None or
                sameProxiedObjects(parent, vhr) or
                IContainmentRoot.providedBy(parent)):
                return None

            if IContentContainer.providedBy(parent):
                url = absoluteURL(parent, request)

                if checkPermission('zojax.ModifyContent', parent):
                    return '%s/@@context.html' % url

                viewName = queryMultiAdapter(
                    (parent, request),
                    IContentViewView
                )
                if viewName:
                    return '%s/%s' % (url, viewName.name)

                return '%s/' % url
            else:
                parent = getattr(parent, '__parent__', None)

    def get_all_docs(self, _type=fields.TYPE_FLAGS_VAL):
        """
        Get all documents for the selected mailbox of the
        passed type. By default, it returns the flag docs.

        If you want acess to the content, use __iter__ instead

        :return: a list of u1db documents
        :rtype: list of SoledadDocument
        """
        if _type not in fields.__dict__.values():
            raise TypeError("Wrong type passed to get_all_docs")

        if sameProxiedObjects(self._soledad, None):
            logger.warning('Tried to get messages but soledad is None!')
            return []

        all_docs = [doc for doc in self._soledad.get_from_index(
            fields.TYPE_MBOX_IDX,
            _type, self.mbox)]

        # inneficient, but first let's grok it and then
        # let's worry about efficiency.
        # XXX FIXINDEX -- should implement order by in soledad
        # FIXME ----------------------------------------------
        return sorted(all_docs, key=lambda item: item.content['uid'])

    def isAvailable(self):
        if super(ErrorConfiglet, self).isAvailable():
            sm = IComponentLookup(getUtility(IErrorReportingUtility))
            if sameProxiedObjects(sm, getSite().getSiteManager()) or \
                IFolder.providedBy(getSite().__parent__):
                return True

        return False

 def visible(self):
     if not checkPermission("schooltool.edit", self.container):
         return False
     authenticated = IPerson(self.request.principal, None)
     target = IPerson(self.context, None)
     if sameProxiedObjects(authenticated, target):
         return False
     return True

    def isInstalled(self):
        sm = getSiteManager()

        auth = sm.getUtility(IAuthentication)
        if not IPluggableAuthentication.providedBy(auth):
            return False

        return sameProxiedObjects(IComponentLookup(auth), sm)

    def isInstalled(self):
        container = queryUtility(ISessionDataContainer)
        if container is not None:
            if isinstance(container, MemCachedSessionDataContainer) and \
                    sameProxiedObjects(
                IComponentLookup(container), getSiteManager()):
                return True

        return False

 def __call__(self):
     app = ISchoolToolApplication(None)
     # XXX: extremely nasty loop through all schedules.
     schedule_containers = app[SCHEDULES_KEY]
     for container in schedule_containers.values():
         for schedule in container.values():
             if (interfaces.ISelectedPeriodsSchedule.providedBy(schedule) and
                 sameProxiedObjects(schedule.timetable, self.object)):
                 del container[schedule.__name__]

 def listTerms(self):
     first, last = self.terms
     result = [first]
     next = getNextTerm(first)
     while (next is not None and
            not sameProxiedObjects(result[-1], next)):
         result.append(next)
         next = getNextTerm(next)
     return result

def validateScholYearsForOverlap(syc, dr, schoolyear):
    overlapping_schoolyears = []
    for other_schoolyear in syc.values():
        if (not sameProxiedObjects(other_schoolyear, schoolyear) and
            dr.overlaps(IDateRange(other_schoolyear))):
            overlapping_schoolyears.append(other_schoolyear)
            if overlapping_schoolyears:
                raise SchoolYearOverlapError(schoolyear,
                                             overlapping_schoolyears)

    def isInstalled(self):
        container = queryUtility(ISessionDataContainer)
        if container is not None:
            if container.__class__ == PersistentSessionDataContainer and \
                    sameProxiedObjects(
                IComponentLookup(container), getSiteManager()):
                return True

        return False

def validateTermsForOverlap(sy, dr, term):
    overlapping_terms = []
    for other_term in sy.values():
        if (not sameProxiedObjects(other_term, term) and
            dr.overlaps(IDateRange(other_term))):
            overlapping_terms.append(other_term)
            if overlapping_terms:
                raise TermOverlapError(term,
                                       overlapping_terms)

    def __call__(self):
        if (self.event.first is None or
            self.event.second is None):
            return # unlinking sections

        first_term = ITerm(self.event.first)
        second_term = ITerm(self.event.second)
        if sameProxiedObjects(first_term, second_term):
            raise InvalidSectionLinkException(
                _("Cannot link sections in same term"))

        if not sameProxiedObjects(ISchoolYear(first_term),
                                  ISchoolYear(second_term)):
            raise InvalidSectionLinkException(
                _("Cannot link sections in different school years"))

        if not sameProxiedObjects(getNextTerm(first_term), second_term):
            raise InvalidSectionLinkException(
                _("Sections must be in consecutive terms"))

    def start_imap_service(self):
        """
        Starts imap service.
        """
        logger.debug('Starting imap service')
        leap_assert(sameProxiedObjects(self._soledad, None)
                    is not True,
                    "We need a non-null soledad for initializing imap service")
        leap_assert(sameProxiedObjects(self._keymanager, None)
                    is not True,
                    "We need a non-null keymanager for initializing imap "
                    "service")

        self.imap_service, self.imap_port, \
            self.imap_factory = imap.start_imap_service(
                self._soledad,
                self._keymanager,
                userid=self.userid)
        self.imap_service.start_loop()