def diffs(self, f1, f2):
	# foreach pair of records
	for idVal, r1, r2 in mergeIter(f1, f2, all=True):
	    r1 = r1 and self.convertZeros(r1) or None
	    r2 = r2 and self.convertZeros(r2) or None
	    # try each comparison
	    for cmpr in self.cmprs:
		try:
		    # report any diffs
		    for d in cmpr.diffs(r1, r2):
			d['id'] = idVal
			d['type'] = self.typ
			if d.get('subject',None) is None:
			    d['subject'] = self.labeler.get(self.stype, idVal, self.sformat)
			    if d['subject'] is None:
				logging.warn("No label found for: "+idVal)
				d['subject'] = '???'
			d['label'] = xmlEscape(d['subject']) + ' [' + idVal + ']'
			d['updateMessage'] = xmlEscape(d['updateMessage'] % d)
			d['pubDate'] = self.pubDate
			yield d
		except:
		    print "ERROR!"
		    print "comparator=",str(cmpr)
		    print "r1=",r1
		    print "r2=",r2
		    raise

    def handleRequest(self, RequestURI='', **kwargs):
        yield httputils.okRss
        yield """<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel>"""
        try:
            Scheme, Netloc, Path, Query, Fragment = urlsplit(RequestURI)
            arguments = parse_qs(Query)
            sortKeys = arguments.get('sortKeys', [self._sortKeys])[0]
            sortBy, sortDescending = None, None
            if sortKeys:
                sortBy, ignored, sortDescending = sortKeys.split(',')
                sortDescending = sortDescending == '1'

            maximumRecords = int(arguments.get('maximumRecords', [self._maximumRecords])[0])
            query = arguments.get('query', [''])[0]
            filters = arguments.get('filter', [])
            startRecord = 1

            if not query and not self._antiUnaryClause:
                raise SruMandatoryParameterNotSuppliedException("query")
            webquery = WebQuery(query, antiUnaryClause=self._antiUnaryClause)
            for filter in filters:
                if not ':' in filter:
                    raise BadRequestException('Invalid filter: %s' % filter)
                field,term = filter.split(':', 1)
                webquery.addFilter(field, term)

            ast = webquery.ast
        except (SruMandatoryParameterNotSuppliedException, BadRequestException, CQLParseException), e:
            yield '<title>ERROR %s</title>' % xmlEscape(self._title)
            yield '<link>%s</link>' % xmlEscape(self._link)
            yield "<description>An error occurred '%s'</description>" % xmlEscape(str(e))
            yield """</channel></rss>"""
            raise StopIteration()

 def _createOutput(self, anUpload):
     if not self._target.oaiEnvelope:
         return anUpload.record
     envelopedata = {
         "identifier": xmlEscape(anUpload.recordIdentifier),
         "metadataPrefix": xmlEscape(str(anUpload.repository.metadataPrefix)),
         "baseurl": xmlEscape(str(anUpload.repository.baseurl)),
         "responseDate": self.tznow(),
         "recordData": lxmltostring(anUpload.record),
     }
     return parse(StringIO(OAI_ENVELOPE % envelopedata), XMLParser(ns_clean=True)).getroot()

 def createRecord(self, dataDictionary):
     try:
         link = self._linkTemplate % dict(((k, urlQuote(v)) for k,v in dataDictionary.items()))
     except KeyError:
         link = ''
     rssData = {
         'link': xmlEscape(link),
         'description': xmlEscape(dataDictionary.get('description', '')),
         'title': xmlEscape(dataDictionary.get('title', ''))
     }
     return str(RSS_TEMPLATE % rssData)

    def handleRequest(self, RequestURI='', **kwargs):
        yield httputils.okRss
        yield """<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel>"""

        try:
            Scheme, Netloc, Path, Query, Fragment = urlsplit(RequestURI)
            arguments = parse_qs(Query)
            sortKeys = arguments.get('sortKeys', [self._sortKeys])[0]
            sortBy, sortDescending = None, None
            if sortKeys:
                sortBy, ignored, sortDescending = sortKeys.split(',')
                sortDescending = sortDescending == '0'

            # Set Language:
            prefLanguage = arguments.get('preflang', [self._supportedLanguages[0]])[0]
            # This might be German:-(  Not anymore :-)
            prefLanguage = prefLanguage if prefLanguage.lower() in self._supportedLanguages else self._supportedLanguages[0]

            # Get max records, from request or get default
            maximumRecords = int(arguments.get('maximumRecords', [self._maximumRecords])[0])
            maximumRecords = maximumRecords if maximumRecords <= self._max_maximumRecords else int(self._max_maximumRecords) # Check if requested max does not exceed our max...

            #set startrecord: we support rss paging...
            startRecord = int(arguments.get('startRecord', [self._startRecord])[0])
            
            #set querylabel:
            querylabel = arguments.get('querylabel', [self._title.get(prefLanguage)])[0]

            #get userquery:
            query = arguments.get('query', [''])[0]
            filters = arguments.get('filter', [])
            # startRecord = 1

            if not query and not self._antiUnaryClause:
                raise SruMandatoryParameterNotSuppliedException("query")

            webquery = WebQuery(query, antiUnaryClause=self._antiUnaryClause)
            for filter in filters:
                if not ':' in filter:
                    raise BadRequestException('Invalid filter: %s' % filter)
                field,term = filter.split(':', 1)
                webquery.addFilter(field, term)

            ast = webquery.ast

        except (SruMandatoryParameterNotSuppliedException, BadRequestException, CQLParseException), e:
            yield '<title>ERROR %s</title>' % xmlEscape(self._title)
            # yield '<link>%s</link>' % xmlEscape(self._link)
            yield '<link>%s</link>' % xmlEscape(self._link.get(prefLanguage))
            yield "<description>An error occurred '%s'</description>" % xmlEscape(str(e))
            yield """</channel></rss>"""
            raise StopIteration()

    def send(self, anUpload):
        anId = anUpload.id
        self._logLine('UPLOAD.SEND', 'START', id = anId)

        recordData = '<document xmlns="http://meresco.org/namespace/harvester/document">%s</document>' % ''.join(
                ['<part name="%s">%s</part>' % (xmlEscape(partName), xmlEscape(partValue)) for partName, partValue in anUpload.parts.items()])

        action = "replace"
        recordIdentifier= xmlEscape(anId)
        recordPacking = 'xml'
        recordSchema = xmlEscape(partName)
        self._sendData(anId, recordUpdate % locals())
        self._logLine('UPLOAD.SEND', 'END', id = anId)

 def result():
     yield '<doc:document xmlns:doc="http://meresco.org/namespace/harvester/document">'
     for subpart, data in resultparts:
         yield '<doc:part name="%s">' % xmlEscape(subpart)
         yield data
         yield '</doc:part>'
     yield '</doc:document>'

 def delete(self, anUpload):
     self._logDelete(anUpload.id)
     action = "delete"
     recordIdentifier = xmlEscape(anUpload.id)
     recordPacking = 'xml'
     recordSchema = 'ignored'
     recordData = '<ignored/>'
     self._sendData(anUpload.id, recordUpdate % locals())

    def _formatHex(self, hexstring):
        '''Add spaces between hex chars, format nicely as HTML'''

        assert len(hexstring) % 2 == 0
        hexWithSpaces = ' '.join(
            hexstring[i:i+2]
            for i in xrange(0, len(hexstring), 2))
        return xmlEscape(hexWithSpaces)

    def echoedExtraRequestData(self, sruArguments, **kwargs):
        requestedTerms = [singleRequest for request in sruArguments.get('x-term-drilldown',[]) for singleRequest in request.split(',') if singleRequest.strip()]
        if requestedTerms:
            outputFormat = sruArguments.get('x-drilldown-format', [self._defaultFormat])[0]
            if outputFormat == FORMAT_OLD_XML:
                yield _DRILLDOWN_HEADER % _DRILLDOWN_XSD_2007
                yield "<dd:term-drilldown>%s</dd:term-drilldown>" % xmlEscape(','.join(requestedTerms))
                yield DRILLDOWN_FOOTER
                return

            yield _DRILLDOWN_HEADER % _DRILLDOWN_XSD_2013
            yield '<dd:request>'
            for term in requestedTerms:
                yield "<dd:x-term-drilldown>%s</dd:x-term-drilldown>" % xmlEscape(term)
            if 'x-drilldown-format' in sruArguments:
                yield "<dd:x-drilldown-format>%s</dd:x-drilldown-format>" % xmlEscape(outputFormat)
            yield '</dd:request>'
            yield DRILLDOWN_FOOTER

 def delete(self, identifier):
     body = """<ucp:updateRequest xmlns:ucp="info:lc/xmlns/update-v1">
         <srw:version xmlns:srw="http://www.loc.gov/zing/srw/">1.0</srw:version>
         <ucp:action>info:srw/action/1/delete</ucp:action>
         <ucp:recordIdentifier>%s</ucp:recordIdentifier>
     </ucp:updateRequest>""" % xmlEscape(identifier)
     response = self._send(body)
     self.checkResponse(response)
     yield

 def _getSetSpecs(self, record):
     if record.sets:
         deletedSets = set()
         if self._deleteInSetsSupport:
             deletedSets = record.deletedSets
         return ''.join('<setSpec{1}>{0}</setSpec>'.format(
                 xmlEscape(setSpec),
                 ' status="deleted"' if setSpec in deletedSets else ''
             ) for setSpec in sorted(record.sets))
     return ''

    def newUserForm(self, session, path, lang=None, extraFields="", **kwargs):
        lang = lang or self._lang
        formValues = session.get('BasicHtmlLoginForm.newUserFormValues', {}) if session else {}
        yield """<div id="login-new-user-form">\n"""
        if not USER in session:
            yield '<p class="error">Please login to add new users.</p>\n</div>'
            return
        if 'errorMessage' in formValues:
            yield '    <p class="error">%s</p>\n' % xmlEscape(formValues['errorMessage'])
        if 'successMessage' in formValues:
            yield '    <p class="success">%s</p>\n' % xmlEscape(formValues['successMessage'])

        values = dict(
            username=quoteattr(formValues.get('username', '')),
            action=quoteattr(join(self._action, 'newUser')),
            formUrl=quoteattr(path),
            returnUrl=quoteattr(kwargs.get('returnUrl', path)),
            lblUsername=getLabel(lang, 'newuserForm', 'username'),
            lblPassword=getLabel(lang, 'newuserForm', 'password'),
            lblPasswordRepeat=getLabel(lang, 'newuserForm', 'password-repeat'),
            lblCreate=getLabel(lang, 'newuserForm', 'create'),
            extraFields=extraFields
        )

        yield """
    <form method="POST" name="newUser" action=%(action)s>
        <input type="hidden" name="formUrl" value=%(formUrl)s/>
        <input type="hidden" name="returnUrl" value=%(returnUrl)s/>
        <dl>
            <dt>%(lblUsername)s</dt>
            <dd><input type="text" name="username" value=%(username)s/></dd>
            <dt>%(lblPassword)s</dt>
            <dd><input type="password" name="password"/></dd>
            <dt>%(lblPasswordRepeat)s</dt>
            <dd><input type="password" name="retypedPassword"/></dd>
            %(extraFields)s
            <dd class="submit"><input type="submit" value="%(lblCreate)s"/></dd>
        </dl>
    </form>
</div>""" % values
        session.pop('BasicHtmlLoginForm.newUserFormValues', None)

    def test0(self):
        """Test story with TOC and a cascaded header hierarchy.

        The story should contain exactly one table of contents that is
        immediatly followed by a list of of cascaded levels of header
        lines, each nested one level deeper than the previous one.

        Features to be visually confirmed by a human being are:

            1. TOC lines are indented in multiples of 1 cm.
            2. Wrapped TOC lines continue with additional 0.5 cm indentation.
            3. Only entries of every second level has links
            ...
        """

        maxLevels = 12

        # Create styles to be used for document headers
        # on differnet levels.
        headerLevelStyles = []
        for i in range(maxLevels):
            headerLevelStyles.append(makeHeaderStyle(i))

        # Create styles to be used for TOC entry lines
        # for headers on differnet levels.
        tocLevelStyles = []
        d, e = tableofcontents.delta, tableofcontents.epsilon
        for i in range(maxLevels):
            tocLevelStyles.append(makeTocHeaderStyle(i, d, e))

        # Build story.
        story = []
        styleSheet = getSampleStyleSheet()
        bt = styleSheet['BodyText']

        description = '<font color=red>%s</font>' % self.test0.__doc__
        story.append(XPreformatted(description, bt))

        toc = tableofcontents.TableOfContents()
        toc.levelStyles = tocLevelStyles
        story.append(toc)

        for i in range(maxLevels):
            story.append(Paragraph('HEADER, LEVEL %d' % i,
                                   headerLevelStyles[i]))
            #now put some body stuff in.
            txt = xmlEscape(randomtext.randomText(randomtext.PYTHON, 5))
            para = Paragraph(txt, makeBodyStyle())
            story.append(para)

        path = outputfile('test_platypus_toc.pdf')
        doc = MyDocTemplate(path)
        doc.multiBuild(story)

 def _termDrilldown(self, drilldownData, format):
     if format == FORMAT_XML:
         self._dd_item = self._dd_item_new
         for facet in drilldownData:
             yield self._dd_navigator(facet['fieldname'], facet['terms'])
     elif format == FORMAT_JSON:
         yield "<dd:json>%s</dd:json>" % xmlEscape(dumps(drilldownData, indent=4))
     elif format == FORMAT_OLD_XML:
         self._dd_item = self._dd_item_old
         for facet in drilldownData:
             yield self._dd_navigator(facet['fieldname'], facet['terms'])
     else:
         raise ValueError("Expected x-drilldown-format to be one of: %s" % str([FORMAT_XML, FORMAT_JSON]))

 def extraResponseData(self, drilldownData, sruArguments, **kwargs):
     if drilldownData is None:
         return
     outputFormat = sruArguments.get('x-drilldown-format', [self._defaultFormat])[0]
     drilldownHeader = _DRILLDOWN_HEADER % (_DRILLDOWN_XSD_2007 if outputFormat == FORMAT_OLD_XML else _DRILLDOWN_XSD_2013)
     try:
         yield decorate(drilldownHeader, self._termDrilldown(drilldownData, format=outputFormat), DRILLDOWN_FOOTER)
     except Exception, e:
         print_exc()
         yield drilldownHeader + "<dd:term-drilldown>"
         yield generalSystemError(xmlEscape(e.args[0]))
         yield "</dd:term-drilldown>" + DRILLDOWN_FOOTER
         return

def uStdQuote(s):
    if not isinstance(s,strTypes):
        if s is None: return u'' #we usually don't want output
        cnv = getattr(s,_ucvn,None)
        if not cnv:
            cnv = getattr(s,_bcvn,None)
        s = cnv() if cnv else unicodeT(s)
    if isinstance(s,_safeBase):
        if isinstance(s,SafeString):
            s = s.decode('utf8')
        return s
    elif not isinstance(s,unicodeT):
        s = s.decode('utf8')
    return xmlEscape(s)

    def userList(self, session, path, userLink=None, **kwargs):
        yield """<div id="login-user-list">\n"""
        if not USER in session:
            yield '<p class="error">Please login to show user list.</p>\n</div>'
            return
        sessionUser = session[USER]
        if sessionUser.canEdit():
            yield """<script type="text/javascript">
function deleteUser(username) {
    if (confirm("Are you sure?")) {
        document.removeUser.username.value = username;
        document.removeUser.submit();
    }
}
            </script>"""
            yield """<form name="removeUser" method="POST" action=%s>
            <input type="hidden" name="formUrl" value=%s/>
            <input type="hidden" name="username"/>""" % (
                    quoteattr(join(self._action, 'remove')),
                    quoteattr(path),
                )
            yield '</form>\n'
        yield '<ul>\n'
        for user in sorted(self._listUsers(), key=lambda u:u.title()):
            yield '<li>'
            if userLink:
                yield '<a href="%s?user=%s">%s</a>' % (userLink, xmlEscape(user.name), xmlEscape(user.title()))
            else:
                yield xmlEscape(user.title())
            if sessionUser.name != user.name and (
                    sessionUser.canEdit(user.name)
                ):
                yield """ <a href="javascript:deleteUser('%s');">delete</a>""" % user.name
            yield '</li>\n'
        yield '</ul>\n'
        yield '</div>\n'

 def _dd_navigator(self, fieldname, terms):
     try:
         firstTerm = terms[0]
         yield '<dd:navigator name=%s>' % quoteattr(fieldname)
         yield self._dd_item(firstTerm)
         for term in terms[1:]:
             yield self._dd_item(term)
         yield '</dd:navigator>'
     except IndexError:
         yield '<dd:navigator name=%s/>' % quoteattr(fieldname)
         return
     except Exception, e:
         print_exc()
         yield generalSystemError(xmlEscape(str(e)))
         return

    def changePasswordForm(self, session, path, arguments, user=None, lang=None, onlyNewPassword=False, **kwargs):
        lang = lang or self._lang
        formValues = session.get('BasicHtmlLoginForm.formValues', {}) if session else {}
        yield """<div id="login-change-password-form">\n"""
        if not USER in session:
            yield '<p class="error">Please login to change password.</p>\n</div>'
            return
        if 'errorMessage' in formValues:
            yield '    <p class="error">%s</p>\n' % xmlEscape(formValues['errorMessage'])

        formUrl = path
        if arguments:
            formUrl += "?" + urlencode(arguments, doseq=True)

        username = session[USER].name if user is None else (user if isinstance(user, basestring) else user.name)
        values = dict(
            action=quoteattr(join(self._action, 'changepassword')),
            formUrl=quoteattr(formUrl),
            returnUrl=quoteattr(kwargs.get('returnUrl', path)),
            username=quoteattr(username),
            lblOldPassword=getLabel(lang, "changepasswordForm", "old-password"),
            lblNewPassword=getLabel(lang, "changepasswordForm", "new-password"),
            lblNewPasswordRepeat=getLabel(lang, "changepasswordForm", "new-password-repeat"),
            lblChange=getLabel(lang, "changepasswordForm", "change"),
        )

        yield """<form method="POST" name="changePassword" action=%(action)s>
        <input type="hidden" name="formUrl" value=%(formUrl)s/>
        <input type="hidden" name="returnUrl" value=%(returnUrl)s/>
        <input type="hidden" name="username" value=%(username)s/>
        <dl>
            """ % values
        if not onlyNewPassword:
            yield """<dt>%(lblOldPassword)s</dt>
            <dd><input type="password" name="oldPassword"/></dd>""" % values
        yield """
            <dt>%(lblNewPassword)s</dt>
            <dd><input type="password" name="newPassword"/></dd>
            <dt>%(lblNewPasswordRepeat)s</dt>
            <dd><input type="password" name="retypedPassword"/></dd>
            <dd class="submit"><input type="submit" value="%(lblChange)s"/></dd>
        </dl>
    </form>
</div>""" % values
        session.pop('BasicHtmlLoginForm.formValues', None)