示例#1
0
文件: tasks.py 项目: changwoo/galkwi
def export(request):
    start = request.GET.get('start')
    response = HttpResponse(mimetype='application/xml')
    query = Entry.all()
    if start:
        query.filter('word >=', start)
    query.filter('valid =', True)
    query.order('word')
    entries = query.fetch(EXPORT_CHUNK_SIZE)
    response.write('<exported-data>\n')
    for entry in entries:
        if not entry.valid:
            continue
        response.write('<Entry>\n')
        response.write('<word>%s</word>\n' % entry.word)
        response.write('<pos>%s</pos>\n' % entry.pos)
        if entry.props:
            response.write('<props>%s</props>\n' % xml_escape(entry.props))
        if entry.stem:
            response.write('<stem>%s</stem>\n' % entry.stem)
        if entry.etym:
            response.write('<etym>%s</etym>\n' % entry.etym)
        if entry.comment:
            response.write('<comment>%s</comment>\n' % xml_escape(entry.comment))
        response.write('<editors>')
        for ekey in entry.editors:
            editor = db.get(ekey)
            response.write('<name>%s</name>' % editor.username)
        response.write('</editors>\n')
        response.write('<editor>%s</editor>\n' % entry.editor.username)
        response.write('<date>%s</date>\n' % entry.date.strftime('%Y-%m-%d %H:%M:%S'))
        response.write('</Entry>\n')
    response.write('</exported-data>\n')
    return response
示例#2
0
 def renderFailure(err, ticket, request):
     log_cas_event("Failed to validate ticket.", [
         ('client_ip', request.getClientIP()),
         ('ticket', ticket)])
     err.trap(InvalidTicket, InvalidProxyCallback, InvalidService)
     request.setResponseCode(403)
     code = "INVALID_TICKET"
     msg = "Validation failed for ticket '%s'." % ticket
     if err.check(InvalidTicketSpec):
         code = "INVALID_TICKET_SPEC"
     elif err.check(InvalidProxyCallback):
         code = "INVALID_PROXY_CALLBACK"
         msg = "Invalid proxy callback."
     elif err.check(InvalidService):
         code = "INVALID_SERVICE"
         msg = "Invalid service."
     doc_fail = dedent("""\
         <cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">
            <cas:authenticationFailure code="%(code)s">
               %(msg)s.    
            </cas:authenticationFailure>
         </cas:serviceResponse>
         """) % {
             'code': xml_escape(code),
             'msg': xml_escape(msg),}
     return doc_fail
示例#3
0
 def _process_report(self):
     while True:
         result = (yield)
         d = {k: getattr(result, k, '') for k in ('category', 'package', 'version')}
         d['class'] = xml_escape(result.name)
         d['msg'] = xml_escape(result.desc)
         self.out.write(self.scope_map.get(result.scope, self.result_template) % d)
示例#4
0
    def to_text_html_resources(self, retval, raw):
        """Add the resources details to the HTML output.

        :param retval: The list of strings which is used to collect the HTML
                       response.
        :type retval: list
        :param raw: The original return value of this resources :func:`GET`
                    method.
        :type raw: Dictionary
        """
        for resource in raw:
            retval.append('<div class="resource_details">')
            retval.append('<h2 id="{0}">{0}</h2>'.format(
                xml_escape(resource['name'])))
            if resource['desc']:
                retval.append('<p class="desc">{0}</p>'.format(xml_escape(resource['desc'])))
            retval.append('<table class="config">')
            retval.append('<tr><th>Path</th><td>{0}</td>'.format(xml_escape(
                resource['path'])))
            representations = [value + ' (.' + key + ')' for key, value
                in resource['properties']['EXTENSION_MAP'].iteritems()]
            retval.append('<tr><th>Representations</th><td>{0}</td>'.format(
                xml_escape(', '.join(representations))))
            retval.append('</table>')
            self.to_text_html_methods(retval, resource)
            retval.append('</div>')
示例#5
0
 def failureResult(err, targetService, pgt, request):
     log_cas_event("Failed to issue proxy ticket", [
         ('client_ip', request.getClientIP()),
         ('targetService', targetService),
         ('PGT', pgt),])
     if not err.check(InvalidTicket, InvalidService):
         log.err(err)
     code = "INTERNAL_ERROR"
     msg = "An internal error occured."
     if err.check(InvalidTicket):
         code = "BAD_PGT"
         msg = "PGT '%s' is invalid." % pgt
     elif err.check(InvalidService):
         code = "INVALID_SERVICE"
         msg = "Target service is not authorized."
     return dedent("""\
         <cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">
             <cas:proxyFailure code="%(code)s">
                 %(msg)s
             </cas:proxyFailure>
         </cas:serviceResponse>
         """) % {
             'code': xml_escape(code),
             'msg': xml_escape(msg),
         }
示例#6
0
    def send_error(self,
                   status,
                   message=None,
                   code='',
                   resource='',
                   extra_headers=None):

        if not message:
            try:
                (_, message) = self.responses[status]
            except KeyError:
                message = 'Unknown'

        self.log_error("code %d, message %s", status, message)
        content = (ERROR_RESPONSE_TEMPLATE % {
            'code': code,
            'message': xml_escape(message),
            'request_id': 42,
            'resource': xml_escape(resource)
        }).encode('utf-8', 'replace')
        self.send_response(status, message)
        self.send_header("Content-Type", 'text/xml; charset="utf-8"')
        self.send_header("Content-Length", str(len(content)))
        if extra_headers:
            for (name, value) in extra_headers.items():
                self.send_header(name, value)
        self.end_headers()
        if self.command != 'HEAD' and status >= 200 and status not in (204,
                                                                       304):
            self.wfile.write(content)
示例#7
0
 def saveXML(self):
     try:
         fp = file(self.filename, 'w')
         fp.write("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n")
         fp.write("<ci>\n")
         fp.write("\t<slot>\n")
         fp.write("\t\t<id>%s</id>\n" % self.ci_slot)
         for item in self.selectedcaid:
             if len(self.selectedcaid):
                 fp.write("\t\t<caid id=\"%s\" />\n" % item[0])
         for item in self.servicelist:
             if len(self.servicelist):
                 psname = xml_escape(item[0])
                 psattr = xml_escape(item[3])
                 if item[2] == 1:
                     fp.write(
                         "\t\t<provider name=\"%s\" dvbnamespace=\"%s\" />\n"
                         % (psname, psattr))
                 else:
                     fp.write("\t\t<service name=\"%s\" ref=\"%s\" />\n" %
                              (psname, psattr))
         fp.write("\t</slot>\n")
         fp.write("</ci>\n")
         fp.flush()
         fsync(fp.fileno())
         fp.close()
     except:
         print "[CI_Config_CI%d] xml not written" % self.ci_slot
         os_unlink(self.filename)
示例#8
0
    def _notifyServicesSLO(self, services):
        template = self._samlLogoutTemplate

        def logerr(err, service):
            log.msg("Error sending SLO to service '%s'." % service)
            log.err(err)
            errs = unwrap_failures(err)
            for error in errs:
                log.err(error)
            return err

        dlist = []
        for service, st in services.iteritems():
            dt = datetime.datetime.utcnow()
            issue_instant = dt.strftime("%Y-%m-%dT%H:%M:%S")
            identifier = str(uuid.uuid4())
            data = template % {
                'identifier': xml_escape(identifier),
                'issue_instant': xml_escape(issue_instant),
                'service_ticket': xml_escape(st)
            }
            httpClient = self.httpClientFactory(self.reactor)
            d = httpClient.post(
                service.encode('utf-8'),
                headers=Headers({'Content-Type': ['application/xml']}),
                data=data.encode('utf-8'),
                timeout=30).addCallback(treq.content).addErrback(
                    logerr, service)
            dlist.append(d)
        return defer.DeferredList(dlist, consumeErrors=True)
示例#9
0
        def upload_results(self, results, path, message=None):
            """ Upload query results CSV to Amazon S3

                :param tuple results: query results for upload
                :param str path: bucket path
                :param str message: text to display before download link
                :return: link text on successful upload, failure message if
                         s3 upload failed

            """
            timer = statsd.timer('bux_sql_grader.upload_results').start()
            if not message:
                message = "Download full results"

            # Convert result rows to CSV
            csv_results = self.csv_results(results)

            # Upload to S3
            s3_url = self.upload_to_s3(csv_results, path)
            if s3_url:
                context = {"url": xml_escape(s3_url), "message": xml_escape(message),
                           "icon_src": xml_escape(self.download_icon)}
                download_link = DOWNLOAD_LINK.substitute(context)
            else:
                download_link = UPLOAD_FAILED_MESSAGE

            timer.stop()
            return download_link
示例#10
0
    def GET(self, env, start_response):
        """
        Handle GET Service request
        """
        env['QUERY_STRING'] = 'format=json'
        body_iter = self._app_call(env)
        status = self._get_status_int()

        if status != HTTP_OK:
            if status in (HTTP_UNAUTHORIZED, HTTP_FORBIDDEN):
                return get_err_response('AccessDenied')
            else:
                return get_err_response('InvalidURI')

        containers = loads(''.join(list(body_iter)))
        # we don't keep the creation time of a backet (s3cmd doesn't
        # work without that) so we use something bogus.
        if containers:
            owner = containers[0].get('owner', '')
        else:
            owner = ''
        body = '<?xml version="1.0" encoding="UTF-8"?>' \
               '<ListAllMyBucketsResult ' \
               'xmlns="http://doc.s3.amazonaws.com/2006-03-01">'\
               '<Owner><ID>%s</ID><DisplayName>%s</DisplayName></Owner>'\
               '<Buckets>%s</Buckets>' \
               '</ListAllMyBucketsResult>' \
               % (xml_escape(owner), xml_escape(owner),
                  "".join(['<Bucket><Name>%s</Name><CreationDate>'
                           '2009-02-03T16:45:09.000Z</CreationDate></Bucket>'
                           % xml_escape(i['name']) for i in containers]))
        resp = Response(status=HTTP_OK, content_type='application/xml',
                        body=body)
        return resp
def create_storage_pool(conn, path, pool_name='default'):
    """Create directory pool."""
    # FIXME: support other types than dir
    xml = '''
	<pool type="dir">
		<name>%(pool)s</name>
		<target>
			<path>%(path)s</path>
		</target>
	</pool>
	''' % {
        'pool': xml_escape(pool_name),
        'path': xml_escape(path),
    }
    try:
        pool = conn.storagePoolDefineXML(xml, 0)
        pool.setAutostart(True)
        pool.create(0)
    except libvirt.libvirtError as ex:
        logger.error(ex)
        raise StorageError(
            _('Error creating storage pool "%(pool)s": %(error)s'),
            pool=pool_name,
            error=ex.get_error_message(),
        )
示例#12
0
文件: plugin.py 项目: OpenDMM/enigma2
	def saveXML(self):
		try:
			fp = file(self.filename, 'w')
			fp.write("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n")
			fp.write("<ci>\n")
			fp.write("\t<slot>\n")
			fp.write("\t\t<id>%s</id>\n" % self.ci_slot)
			for item in self.selectedcaid:
				if len(self.selectedcaid):
					fp.write("\t\t<caid id=\"%s\" />\n" % item[0])
			for item in self.servicelist:
				if len(self.servicelist):
					psname = xml_escape(item[0])
					psattr = xml_escape(item[3])
					if item[2]==1:
						fp.write("\t\t<provider name=\"%s\" dvbnamespace=\"%s\" />\n" % (psname, psattr))
					else:
						fp.write("\t\t<service name=\"%s\" ref=\"%s\" />\n"  % (psname, psattr))
			fp.write("\t</slot>\n")
			fp.write("</ci>\n")
			fp.flush()
			fsync(fp.fileno())
			fp.close()
		except:
			print "[CI_Config_CI%d] xml not written" %self.ci_slot
			os_unlink(self.filename)
示例#13
0
文件: rubik.py 项目: Borsos/rubik-7
    def __init__(self, app, name, hotkey):
        self.app = app
        self.name = name
        self.hotkey = hotkey

        # configuration values
        self.examination_time = self.app.conf["examination_time"]

        # remove window from container
        builder = self.app.create_builder()
        self.window = builder.get_object("player_window")
        container = builder.get_object("player_window_container")
        container.remove(self.window)

        # set player name
        builder.get_object("player_name").set_markup(self.player_markup % xml_escape(name))

        # attach
        self.app.attach(self)
        builder.get_object("stop_button_label").set_markup(self.button_markup % xml_escape(button_name(self.hotkey)))

        # cache object refs
        self.time_label = builder.get_object("time_label")

        self.reset()

        builder.connect_signals(self)
        self.window.show()
示例#14
0
    def _notifyServicesSLO(self, services):
        template = self._samlLogoutTemplate

        def logerr(err, service):
            log.msg("Error sending SLO to service '%s'." % service)
            log.err(err)
            errs = unwrap_failures(err)
            for error in errs:
                log.err(error)
            return err

        dlist = []
        for service, st in services.iteritems():
            dt = datetime.datetime.utcnow()
            issue_instant = dt.strftime("%Y-%m-%dT%H:%M:%S")
            identifier = str(uuid.uuid4())
            data = template % {
                'identifier': xml_escape(identifier),
                'issue_instant': xml_escape(issue_instant),
                'service_ticket': xml_escape(st)
            }
            httpClient = self.httpClientFactory(self.reactor)
            d = httpClient.post(
                    service.encode('utf-8'), 
                    headers=Headers({'Content-Type': ['application/xml']}),
                    data=data.encode('utf-8'), 
                    timeout=30).addCallback(
                treq.content).addErrback(
                logerr, service)
            dlist.append(d)
        return defer.DeferredList(dlist, consumeErrors=True)
示例#15
0
def iter_doc_annotations_xml_text(
        doc_annotations: List[Tuple[str, str]]) -> Iterable[str]:
    LOGGER.debug('doc_annotations: %s', doc_annotations)
    text_tokens = [token_text for token_text, _ in doc_annotations]
    token_labels = [token_label for _, token_label in doc_annotations]
    entity_chunks = list(iter_add_untagged_token_spans(
        get_entities(token_labels),
        len(token_labels)
    ))
    LOGGER.debug('text_tokens: %s', text_tokens)
    LOGGER.debug('token_labels: %s', token_labels)
    LOGGER.debug('entity_chunks: %s', entity_chunks)
    return '\n'.join((
        (
            '    <{tag}>{text}</{tag}>'.format(
                tag=get_xml_tag_for_annotation_label(chunk_type),
                text=xml_escape(' '.join(text_tokens[chunk_start:chunk_end + 1]))
            )
            if chunk_type
            else
            '    {text}'.format(
                text=xml_escape(' '.join(text_tokens[chunk_start:chunk_end + 1]))
            )
        )
        for chunk_type, chunk_start, chunk_end in entity_chunks
    )) + '\n'
示例#16
0
 def create_xml(self):
     template = u'<attendees><person>%(first)s%(last)s%(email)s</person>%(session_key)s<joinStatus>ACCEPT</joinStatus><emailInvitations>TRUE</emailInvitations></attendees>'
     template_bits = {
             'first': self.first_name and '<firstName>%s</firstName>'%xml_escape(self.first_name) or '',
             'last': self.last_name and '<lastName>%s</lastName>'%xml_escape(self.last_name) or '',
             'email': '<email>%s</email>'%xml_escape(self.email),
             'session_key': '<sessionKey>%s</sessionKey>'%self.event.session_key }
     return template % template_bits
示例#17
0
def create_xml(cfg):
    """ convert config dict to xml """
    xml= "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n"
    xml += "<map>\n"
    for k,v in cfg.items():
        xml += "    <string name=\"%s\">%s</string>\n" % (xml_escape(k), xml_escape(v))
    xml += "</map>\n"

    return xml
示例#18
0
文件: s3.py 项目: naeloob/s3ql
    def _delete_multi(self, keys, force=False):

        body = ['<Delete>']
        esc_prefix = xml_escape(self.prefix)
        for key in keys:
            body.append('<Object><Key>%s%s</Key></Object>' %
                        (esc_prefix, xml_escape(key)))
        body.append('</Delete>')
        body = '\n'.join(body).encode('utf-8')
        headers = {'content-type': 'text/xml; charset=utf-8'}

        resp = self._do_request('POST',
                                '/',
                                subres='delete',
                                body=body,
                                headers=headers)
        try:
            root = self._parse_xml_response(resp)
            ns_p = self.xml_ns_prefix

            error_tags = root.findall(ns_p + 'Error')
            if not error_tags:
                # No errors occured, everything has been deleted
                del keys[:]
                return

            # Some errors occured, so we need to determine what has
            # been deleted and what hasn't
            offset = len(self.prefix)
            for tag in root.findall(ns_p + 'Deleted'):
                fullkey = tag.find(ns_p + 'Key').text
                assert fullkey.startswith(self.prefix)
                keys.remove(fullkey[offset:])

            if log.isEnabledFor(logging.DEBUG):
                for errtag in error_tags:
                    log.debug('Delete %s failed with %s',
                              errtag.findtext(ns_p + 'Key')[offset:],
                              errtag.findtext(ns_p + 'Code'))

            # If *force*, just modify the passed list and return without
            # raising an exception, otherwise raise exception for the first error
            if force:
                return

            errcode = error_tags[0].findtext(ns_p + 'Code')
            errmsg = error_tags[0].findtext(ns_p + 'Message')
            errkey = error_tags[0].findtext(ns_p + 'Key')[offset:]

            if errcode == 'NoSuchKeyError':
                raise NoSuchObject(errkey)
            else:
                raise get_S3Error(errcode,
                                  'Error deleting %s: %s' % (errkey, errmsg))

        except:
            self.conn.discard()
示例#19
0
def create_xml(cfg):
    """ convert config dict to xml """
    xml= "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n"
    xml += "<map>\n"
    for k,v in cfg.items():
        xml += "    <string name=\"%s\">%s</string>\n" % (xml_escape(k), xml_escape(v))
    xml += "</map>\n"

    return xml
示例#20
0
    def _generate_loc_file(self):
        # Only generate this junk if needed
        if not self._strings and not self._journals:
            return

        def write_line(value, *args, **kwargs):
            # tabs suck, then you die...
            whitespace = "    " * kwargs.pop("indent", 0)
            if args or kwargs:
                value = value.format(*args, **kwargs)
            line = "".join((whitespace, value, "\n"))
            stream.write(line.encode("utf-16_le"))

        age_name = self._age_name
        enc = plEncryptedStream.kEncAes if self._version == pvEoa else None
        file_name = "{}.loc".format(age_name)
        with self._generate_file(file_name, enc=enc) as stream:
            # UTF-16 little endian byte order mark
            stream.write(b"\xFF\xFE")

            write_line("<?xml version=\"1.0\" encoding=\"utf-16\"?>")
            write_line("<localizations>")
            write_line("<age name=\"{}\">", age_name, indent=1)

            # Arbitrary strings defined by something like a GUI or a node tree
            for set_name, elements in self._strings.items():
                write_line("<set name=\"{}\">", set_name, indent=2)
                for element_name, translations in elements.items():
                    write_line("<element name=\"{}\">", element_name, indent=3)
                    for language_name, value in translations.items():
                        write_line(
                            "<translation language=\"{language}\">{translation}</translation>",
                            language=language_name,
                            translation=xml_escape(value),
                            indent=4)
                    write_line("</element>", indent=3)
                write_line("</set>", indent=2)

            # Journals
            if self._journals:
                write_line("<set name=\"Journals\">", indent=2)
                for journal_name, translations in self._journals.items():
                    write_line("<element name=\"{}\">", journal_name, indent=3)
                    for language_name, value in translations.items():
                        write_line(
                            "<translation language=\"{language}\">{translation}</translation>",
                            language=language_name,
                            translation=xml_escape(value),
                            indent=4)
                    write_line("</element>", indent=3)
                write_line("</set>", indent=2)

            # Verbose XML junk...
            # <Deledrius> You call it verbose.  I call it unambiguously complete.
            write_line("</age>", indent=1)
            write_line("</localizations>")
def store_photo(user_id, credentials, photoset_id, photo, title, description,
                tags, on_success, on_error):
    """
    this will call on_success with a dictionary of the new image,
    including 'id' and 'url'
    """

    # in smugmug, the base64-encoded photo is what we need to upload
    def internal_on_success(content):
        "it's XML, let's just pass it for now"
        on_success(content)

    def internal_on_error(error):
        on_error("couldn't upload image: %s" % error)

    # prepare a multipart-mime message

    # first the Atom description (FIXME: XML inline is kinda ugly)
    metadata = """
<entry xmlns='http://www.w3.org/2005/Atom'>
  <title>%s</title>
  <summary>%s</summary>
  <category scheme="http://schemas.google.com/g/2005#kind"
    term="http://schemas.google.com/photos/2007#photo"/>
</entry>
""" % (xml_escape(title), xml_escape(description))

    # treat the photo as a file
    photo_file = cStringIO.StringIO(base64.b64decode(photo))

    boundary, body = utils.multipart_encode(
        vars={},
        vars_with_types=[("application/atom+xml", metadata)],
        files=[("photo", "thefile.jpg", photo_file, "image/jpg")])

    # prepend a bogus line, as per picasa spec (is this MIME?)
    full_body = """
Media multipart posting
%s""" % body

    headers = {
        "Content-Type": "multipart/related; boundary=" + boundary,
        "Content-Length": str(len(full_body)),
        "MIME-Version": "1.0",
    }

    _signed_request(
        "POST",
        "https://picasaweb.google.com/data/feed/api/user/default/albumid/%s" %
        photoset_id,
        params=full_body,
        oauth_extra_params=None,
        credentials=credentials,
        on_success=internal_on_success,
        on_error=internal_on_error,
        headers=headers)
示例#22
0
        def build_response(self, correct, score, hints, student_results,
                           student_warnings=[], grader_results=None,
                           grader_warnings=[], row_limit=None,
                           download_link=""):
            """ Builds a grader response dict. """

            response = {"correct": correct, "score": score}

            # Response message template context
            context = {"download_link": download_link, "hints": ""}

            # Generate student response results table
            context["student_results"] = self.html_results(student_results,
                                                           row_limit)

            # Generate warning messages if queries had to be modified
            notices = ""
            if student_warnings:
                student_warnings = [xml_escape(notice) for notice in student_warnings]
                student_warning = "<strong>Warning</strong><p>"
                student_warning += "</p><p>".join(student_warnings) + "</p>"
                notices += WARNING_TMPL.substitute(msg=student_warning)

            if grader_warnings:
                grader_warnings = [xml_escape(notice) for notice in grader_warnings]
                grader_warning = "<strong>Warning</strong><p>"
                grader_warning += "</p><p>".join(grader_warnings) + "</p>"
                notices += WARNING_TMPL.substitute(msg=grader_warning)

            context["notices"] = notices

            if grader_results and not correct:

                # Generate grader response results table
                context["grader_results"] = self.html_results(grader_results,
                                                              row_limit)

                # Generate hints markup if hints were provided
                if hints:
                    # Ensure hint text is XML-safe
                    hints = [xml_escape(hint) for hint in hints]

                    hints_html = "<strong>Hints</strong>"
                    hints_html += "<ul><li>"
                    hints_html += "</li><li>".join(hints)
                    hints_html += "</li></ul>"

                    context["hints"] = hints_html

                # Incorrect response template
                response["msg"] = INCORRECT_QUERY.substitute(context)
            else:
                # Correct response template
                response["msg"] = CORRECT_QUERY.substitute(context)

            return response
示例#23
0
 def _process_report(self):
     while True:
         result = (yield)
         d = {
             k: getattr(result, k, '')
             for k in ('category', 'package', 'version')
         }
         d['class'] = xml_escape(result.__class__.__name__)
         d['msg'] = xml_escape(result.desc)
         self.out.write(self.scope_map[result.scope] % d)
示例#24
0
文件: services.py 项目: dpla/akara
 def __init__(self, code, message=None):
     assert isinstance(code, int) # Being a bit paranoid about the API
     self.code = code
     self.reason, self.message = http_responses[code]
     if message is not None:
         self.message = message
     self.text = ERROR_DOCUMENT_TEMPLATE % dict(code=self.code,
                                                reason=xml_escape(self.reason),
                                                message=xml_escape(self.message))
     self.headers = [("Content-Type", "text/html")]
示例#25
0
def innerXML(node):
    if len(node) > 0:
        text = xml_escape(node.text or '')
        for child in node:
            text += outterXML(child)
            if child.tail:
                text += xml_escape(child.tail)
        return text or ''
    else:
        return xml_escape(node.text or '')
示例#26
0
    def _get_attrs_str(self):
        attr_decls = []

        for attr, value in self._attrs.items():
            if value is not None:
                attr_decls.append('%s=%s' % (xml_escape(attr), attr_escape(str(value))))
            else:
                attr_decls.append('%s' % xml_escape(attr))

        return ' '.join(attr_decls)
示例#27
0
文件: s3.py 项目: abc3267454/s3ql
    def _delete_multi(self, keys, force=False):

        body = [ '<Delete>' ]
        esc_prefix = xml_escape(self.prefix)
        for key in keys:
            body.append('<Object><Key>%s%s</Key></Object>' % (esc_prefix, xml_escape(key)))
        body.append('</Delete>')
        body = '\n'.join(body).encode('utf-8')
        headers = { 'content-type': 'text/xml; charset=utf-8' }
        
        resp = self._do_request('POST', '/', subres='delete', body=body, headers=headers)
        try:
            root = self._parse_xml_response(resp)
            ns_p = self.xml_ns_prefix
            
            error_tags = root.findall(ns_p + 'Error')
            if not error_tags:
                # No errors occured, everything has been deleted
                del keys[:]
                return

            # Some errors occured, so we need to determine what has
            # been deleted and what hasn't
            offset = len(self.prefix)
            for tag in root.findall(ns_p + 'Deleted'):
                fullkey = tag.find(ns_p + 'Key').text
                assert fullkey.startswith(self.prefix)
                keys.remove(fullkey[offset:])

            if log.isEnabledFor(logging.DEBUG):
                for errtag in error_tags:
                    log.debug('Delete %s failed with %s', 
                              errtag.findtext(ns_p + 'Key')[offset:],
                              errtag.findtext(ns_p + 'Code'))
                
            # If *force*, just modify the passed list and return without
            # raising an exception, otherwise raise exception for the first error
            if force:
                return

            errcode = error_tags[0].findtext(ns_p + 'Code')
            errmsg = error_tags[0].findtext(ns_p + 'Message')
            errkey = error_tags[0].findtext(ns_p + 'Key')[offset:]

            if errcode == 'NoSuchKeyError':
                raise NoSuchObject(errkey)
            else:
                raise get_S3Error(errcode, 'Error deleting %s: %s' % (errkey, errmsg))

        finally:
            # Need to read rest of response
            while True:
                buf = resp.read(BUFSIZE)
                if buf == b'':
                    break
示例#28
0
文件: utils.py 项目: Pike/pontoon
def build_translation_memory_file(creation_date, locale_code, entries):
    """
    TMX files will contain large amount of entries and it's impossible to render all the data with
    django templates.
    Rendering of string in memory is a lot faster.
    :arg datetime creation_date: when TMX file is being created.
    :arg str locale_code: code of a locale
    :arg list entries: A list which contains tuples with following items:
                         * resource_path - path of a resource,
                         * key - key of an entity,
                         * source - source string of entity,
                         * target - translated string,
                         * project_name - name of a project,
                         * project_slug - slugified name of a project,
    """
    yield (
        u'<?xml version="1.0" encoding="utf-8" ?>'
        u'\n<tmx version="1.4">'
        u'\n\t<header'
        u' adminlang="en-US"'
        u' creationtoolversion="0.1"'
        u' creationtool="pontoon"'
        u' datatype="plaintext"'
        u' segtype="sentence"'
        u' o-tmf="plain text"'
        u' srclang="en-US"'
        u' creationdate="%(creation_date)s">'
        u'\n\t</header>'
        u'\n\t<body>' % {
            'creation_date': creation_date.isoformat()
        }
    )
    for resource_path, key, source, target, project_name, project_slug in entries:
        tuid = ':'.join((project_slug, slugify(resource_path), slugify(key)))
        yield (
            u'\n\t\t<tu tuid=%(tuid)s srclang="en-US">'
            u'\n\t\t\t<tuv xml:lang="en-US">'
            u'\n\t\t\t\t<seg>%(source)s</seg>'
            u'\n\t\t\t</tuv>'
            u'\n\t\t\t<tuv xml:lang=%(locale_code)s>'
            u'\n\t\t\t\t<seg>%(target)s</seg>'
            u'\n\t\t\t</tuv>'
            u'\n\t\t</tu>' % {
                'tuid': quoteattr(tuid),
                'source': xml_escape(source),
                'locale_code': quoteattr(locale_code),
                'target': xml_escape(target),
                'project_name': xml_escape(project_name),
            }
        )

    yield (
        u'\n\t</body>'
        u'\n</tmx>'
    )
示例#29
0
def build_translation_memory_file(creation_date, locale_code, entries):
    """
    TMX files will contain large amount of entries and it's impossible to render all the data with
    django templates.
    Rendering of string in memory is a lot faster.
    :arg datetime creation_date: when TMX file is being created.
    :arg str locale_code: code of a locale
    :arg list entries: A list which contains tuples with following items:
                         * resource_path - path of a resource,
                         * key - key of an entity,
                         * source - source string of entity,
                         * target - translated string,
                         * project_name - name of a project,
                         * project_slug - slugified name of a project,
    """
    yield (
        u'<?xml version="1.0" encoding="utf-8" ?>'
        u'\n<tmx version="1.4">'
        u'\n\t<header'
        u' adminlang="en-US"'
        u' creationtoolversion="0.1"'
        u' creationtool="pontoon"'
        u' datatype="plaintext"'
        u' segtype="sentence"'
        u' o-tmf="plain text"'
        u' srclang="en-US"'
        u' creationdate="%(creation_date)s">'
        u'\n\t</header>'
        u'\n\t<body>' % {
            'creation_date': creation_date.isoformat()
        }
    )
    for resource_path, key, source, target, project_name, project_slug in entries:
        tuid = ':'.join((project_slug, resource_path, slugify(key)))
        yield (
            u'\n\t\t<tu tuid=%(tuid)s srclang="en-US">'
            u'\n\t\t\t<tuv xml:lang="en-US">'
            u'\n\t\t\t\t<seg>%(source)s</seg>'
            u'\n\t\t\t</tuv>'
            u'\n\t\t\t<tuv xml:lang=%(locale_code)s>'
            u'\n\t\t\t\t<seg>%(target)s</seg>'
            u'\n\t\t\t</tuv>'
            u'\n\t\t</tu>' % {
                'tuid': quoteattr(tuid),
                'source': xml_escape(source),
                'locale_code': quoteattr(locale_code),
                'target': xml_escape(target),
                'project_name': xml_escape(project_name),
            }
        )

    yield (
        u'\n\t</body>'
        u'\n</tmx>'
    )
示例#30
0
 def __init__(self, code, message=None):
     assert isinstance(code, int)  # Being a bit paranoid about the API
     self.code = code
     self.reason, self.message = http_responses[code]
     if message is not None:
         self.message = message
     self.text = ERROR_DOCUMENT_TEMPLATE % dict(
         code=self.code,
         reason=xml_escape(self.reason),
         message=xml_escape(self.message))
     self.headers = [("Content-Type", "text/html")]
示例#31
0
文件: json_api.py 项目: doadin/deluge
 def _on_torrent_status(self, torrent, d):
     for key in self.XSS_VULN_KEYS:
         try:
             if key == 'peers':
                 for peer in torrent[key]:
                     peer['client'] = xml_escape(peer['client'])
             else:
                 torrent[key] = xml_escape(torrent[key])
         except KeyError:
             pass
     d.callback(torrent)
示例#32
0
文件: cfg2dot.py 项目: avakar/cpp2sir
def cfg2dot(fin, fout):
    import json
    src = json.load(fin)['cfgs']

    fout.write('digraph G {\n')
    fout.write('    node [shape=record];\n')
    fnidx = 0
    for fnname, fn in src.iteritems():
        skipexit2 = True
        for node in fn['nodes']:
            for succ in node[1]:
                if succ[1] != 2 and fn['nodes'][succ[0]][0] == 'exit' and fn['nodes'][succ[0]][2][0][1] == '2':
                    skipexit2 = False
                    break
            if not skipexit2:
                break

        fout.write('    entry%d [label="%s"];\n' % (fnidx, xml_escape(fnname)))
        fout.write('    entry%d -> node%d_%d;\n' % (fnidx, fnidx, fn['entry']))
        for i, node in enumerate(fn['nodes']):
            if skipexit2 and node[0] == 'exit' and node[2][0][1] == '2':
                continue

            if node[0] == 'call':
                ops = node[2][1:]
                opstr = node[2][0][1] + '('
            elif node[0] == 'value':
                ops = node[2]
                opstr = ''
            else:
                ops = node[2]
                opstr = node[0] + '['
            args = []
            for op in ops:
                if op[0] == 'varptr':
                    args.append('&' + str(op[1]))
                elif op[0] != 'node':
                    args.append(str(op[1]))
                else:
                    args.append('$' + str(op[1]))
            opstr = opstr + ', '.join(args)
            if node[0] == 'call':
                opstr = opstr + ')'
            elif node[0] != 'value':
                opstr = opstr + ']'
            fout.write('    node%d_%d [label="<f1> %d |<f2> %s"];\n' % (fnidx, i, i, xml_escape(opstr)));
            for succ in node[1]:
                if succ[1] == 0:
                    fout.write('    node%d_%d -> node%d_%d [label="%s"];\n' % (fnidx, i, fnidx, succ[0], xml_escape(convert_sir_const(succ[2]))))
                if succ[1] == 1:
                    fout.write('    node%d_%d -> node%d_%d [label="%s",style="dotted"];\n' % (fnidx, i, fnidx, succ[0], xml_escape(convert_sir_const(succ[2]))))
        fnidx += 1
    fout.write('}')
示例#33
0
def scrape(comic_id):

  title, strips = get_homepage_data(comic_id)

  xmlContent=[]
  xmlContent.append('<?xml version="1.0" encoding="utf-8"?>')
  xmlContent.append('<feed xmlns="http://www.w3.org/2005/Atom">')
  xmlContent.append('<title>%s</title>' % xml_escape(title))

  strip_count = 0
  for strip_date, strip_url in strips:	  
    counter=0
    #print time.localtime()
    while True:  
      try:  
        strip_image_url = get_strip_image_url(strip_url)
        break
      except :
        print ("Retrying %s in %d" % (strip_url, SLEEP_BETWEEN_RETRIES), file=sys.stderr)
        counter=counter+1
        if counter >=MAX_RETRIES:
          break
        time.sleep(SLEEP_BETWEEN_RETRIES)
    if not strip_image_url:
      continue
    strip_count += 1
    xmlContent.append('<entry>')
    xmlContent.append('  <title>%s</title>' % xml_escape(strip_date.strftime('%A, %B %d, %Y')))
    xmlContent.append('  <id>%s</id>' % strip_url)
    xmlContent.append('  <published>%sT12:00:00.000Z</published>' % strip_date.isoformat())
    xmlContent.append('  <link rel="alternate" href="%s" type="text/html"/>' % xml_escape(strip_url))
    xmlContent.append('  <content type="xhtml">')
    xmlContent.append('    <div xmlns="%s"><img src="%s"/></div>' % (XHTML_NS, xml_escape(strip_image_url)))
    xmlContent.append('  </content>')
    xmlContent.append('</entry>')
    
    time.sleep(SLEEP_BETWEEN_COMICS)
    

  #if not strip_count:
    #xmlContent.append '<entry>'
    #xmlContent.append '  <title>Could not scrape feed</title>'
    #xmlContent.append '  <id>tag:persistent.info,2013:gocomics-scrape-%d</id>' % int(time.time())
    #xmlContent.append '  <link rel="alternate" href="https://github.com/mihaip/feed-scraping" type="text/html"/>'
    #xmlContent.append '  <content type="html">'
    #xmlContent.append '    Could not scrape the feed. Check the GitHub repository for updates.'
    #xmlContent.append '  </content>'
    #xmlContent.append '</entry>'


  xmlContent.append('</feed>')
  
  return "\n".join(xmlContent)
示例#34
0
def markdown_first_paragraph(text):
    try:
        rendered = markdown(text, safe_mode='escape')
        # Extract the contents of the first <p>
        root = lxml.etree.fromstring('<div>' + rendered + '</div>')
        first_para = root.find('p')
        html_content = ''.join([xml_escape(first_para.text or '')] + [
            lxml.etree.tostring(child) for child in first_para.iterchildren()
        ] + [xml_escape(first_para.tail or '')])
        return XML(html_content)
    except Exception:
        return text
示例#35
0
def markdown_first_paragraph(text):
    try:
        rendered = markdown(text, safe_mode='escape')
        # Extract the contents of the first <p>
        root = lxml.etree.fromstring('<div>' + rendered + '</div>')
        first_para = root.find('p')
        html_content = ''.join(
                [xml_escape(first_para.text or '')] +
                [lxml.etree.tostring(child) for child in first_para.iterchildren()] +
                [xml_escape(first_para.tail or '')])
        return XML(html_content)
    except Exception:
        return text
示例#36
0
    def upsert_xml(self):
        return u"""
<accessControl><listing>%s</listing>%s</accessControl>%s
<schedule><startDate>%s</startDate><duration>%s</duration><timeZoneID>%s</timeZoneID></schedule>
<metaData><sessionName>%s</sessionName><description>%s</description></metaData> """ % (
            self.visibility.upper(), self.account.meetings_require_password
            and '<sessionPassword>0000</sessionPassword>'
            or '', self.session_key and
            ('<sessionKey>%s</sessionKey>' % self.session_key) or '',
            self.starts_at.strftime("%m/%d/%Y %H:%M:%S"),
            (self.ends_at - self.starts_at).m,
            timezone.get_id(self.starts_at.tz.zone), xml_escape(
                self.title), xml_escape(self.description))
示例#37
0
文件: event.py 项目: prior/webexpy
    def upsert_xml(self):
        return u"""
<accessControl><listing>%s</listing>%s</accessControl>%s
<schedule><startDate>%s</startDate><duration>%s</duration><timeZoneID>%s</timeZoneID></schedule>
<metaData><sessionName>%s</sessionName><description>%s</description></metaData> """ % (
        self.visibility.upper(),
        self.account.meetings_require_password and '<sessionPassword>0000</sessionPassword>' or '',
        self.session_key and ('<sessionKey>%s</sessionKey>'%self.session_key) or '',
        self.starts_at.strftime("%m/%d/%Y %H:%M:%S"),
        (self.ends_at-self.starts_at).m,
        timezone.get_id(self.starts_at.tz.zone),
        xml_escape(self.title),
        xml_escape(self.description))
def format_lexc_xml(wordmap):
    analysis = xml_escape(wordmap["lemma"])
    analysis = analysis.replace("|", '<s mcs="wb"/>').replace("_", '<s mcs="mb"/>')
    analysis += '<s mcs="' + wordmap["pos"] + '"/>'
    if wordmap["is_proper"]:
        analysis += '<s mcs="proper"/>'
    if wordmap["is_suffix"]:
        analysis = "<s mcs='suffix'/>" + analysis
    if wordmap["is_prefix"]:
        analysis += "<s mcs='prefix'/>"
    stub = xml_escape(wordmap["stub"])
    stub = stub.replace("|", '<s mcs="wb"/>').replace("_", '<s mcs="mb"/>')
    return '    <e><a>%s</a><i>%s</i><cont lexica="%s"/></e>' % (analysis, stub, wordmap["new_para"])
示例#39
0
 def do_export(self, file):
     entries = Entry.objects.filter(latest__deleted=False)
     entries = entries.order_by('latest__word__word')
     file.write('<galkwi-exported version="2.0">\n')
     for entry in entries:
         rev = entry.latest
         word = rev.word
         file.write('<Entry>\n')
         file.write(' <word>%s</word>\n' % xml_escape(word.word))
         file.write(' <pos>%s</pos>\n' % xml_escape(word.pos))
         if word.props:
             file.write(' <props>%s</props>\n' % xml_escape(word.props))
         if word.stem:
             file.write(' <stem>%s</stem>\n' % xml_escape(word.stem))
         if word.etym:
             file.write(' <etym>%s</etym>\n' % xml_escape(word.etym))
         if word.description:
             file.write(' <description>%s</description>\n' %
                        xml_escape(word.description))
         file.write(' <revisions>\n')
         while rev:
             file.write('  <revision>\n')
             file.write('   <name>%s</name>\n' %
                        xml_escape(rev.user.username))
             timestamp = rev.timestamp.astimezone(timezone.utc)
             file.write('   <datetime>%s</datetime>\n' %
                        timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'))
             if rev.comment:
                 file.write('  <comment>%s</comment>\n' %
                            xml_escape(rev.comment))
             file.write('  </revision>\n')
             rev = rev.parent
         file.write(' </revisions>\n')
         file.write('</Entry>\n')
     file.write('</galkwi-exported>\n')
示例#40
0
    def cmd_export(self):
        """USAGE: canto-remote export

    This will print an OPML file to standard output."""

        print("""<opml version="1.0">""")
        print("""\t<body>""")
        for f in self._get_feeds():
            print("""\t\t<outline text="%s" xmlUrl="%s" type="rss" />""" %\
                (xml_escape(f["name"].replace("\"","\\\"")),
                 xml_escape(f["url"])))

        print("""\t</body>""")
        print("""</opml>""")
示例#41
0
def convert_aspectFilters(webParams, APIParams):
    for k, v in webParams.items():
        if k[0].isupper():
            assert (len(v) == 1)
            v = v[0]
            del webParams[k]
            aspectFilters = APIParams.get('aspectFilter', [])
            aspects = urlparse.unquote(v).split('|')  # todo unicode ?
            aspects = [
                'Not Specified' if x == '!' else xml_escape(x) for x in aspects
            ]
            k = drop_bell(xml_escape(k))
            aspectFilters.append({'aspectName': k, 'aspectValueName': aspects})
            APIParams['aspectFilter'] = aspectFilters
示例#42
0
文件: locman.py 项目: H-uru/korman
    def _generate_loc_file(self):
        # Only generate this junk if needed
        if not self._strings and not self._journals:
            return

        def write_line(value, *args, **kwargs):
            # tabs suck, then you die...
            whitespace = "    " * kwargs.pop("indent", 0)
            if args or kwargs:
                value = value.format(*args, **kwargs)
            line = "".join((whitespace, value, "\n"))
            stream.write(line.encode("utf-16_le"))

        age_name = self._age_name
        enc = plEncryptedStream.kEncAes if self._version == pvEoa else None
        file_name = "{}.loc".format(age_name)
        with self._generate_file(file_name, enc=enc) as stream:
            # UTF-16 little endian byte order mark
            stream.write(b"\xFF\xFE")

            write_line("<?xml version=\"1.0\" encoding=\"utf-16\"?>")
            write_line("<localizations>")
            write_line("<age name=\"{}\">", age_name, indent=1)

            # Arbitrary strings defined by something like a GUI or a node tree
            for set_name, elements in self._strings.items():
                write_line("<set name=\"{}\">", set_name, indent=2)
                for element_name, translations in elements.items():
                    write_line("<element name=\"{}\">", element_name, indent=3)
                    for language_name, value in translations.items():
                        write_line("<translation language=\"{language}\">{translation}</translation>",
                                   language=language_name, translation=xml_escape(value), indent=4)
                    write_line("</element>", indent=3)
                write_line("</set>", indent=2)

            # Journals
            if self._journals:
                write_line("<set name=\"Journals\">", indent=2)
                for journal_name, translations in self._journals.items():
                    write_line("<element name=\"{}\">", journal_name, indent=3)
                    for language_name, value in translations.items():
                        write_line("<translation language=\"{language}\">{translation}</translation>",
                                   language=language_name, translation=xml_escape(value), indent=4)
                    write_line("</element>", indent=3)
                write_line("</set>", indent=2)

            # Verbose XML junk...
            # <Deledrius> You call it verbose.  I call it unambiguously complete.
            write_line("</age>", indent=1)
            write_line("</localizations>")
示例#43
0
文件: wizards.py 项目: B-Rich/smart
	def _list_domain_settings( self, object ):
		'''add list with domain settings to page 2'''
		rows = []
		settings = umcd.List()
		for text, key in ( ( _( 'Name' ), 'name' ), ( _( 'Description' ), 'description' ), ( _( 'CPUs' ), 'cpus' ), ( _( 'Memory' ), 'memory' ) ):
			if object.options.get( key ):
				settings.add_row( [ umcd.HTML( '<i>%s</i>' % text ), object.options.get( key, '' ) ] )
			else:
				settings.add_row( [ umcd.HTML( '<i>%s</i>' % text ) ] )
		if object.options.get( 'vnc' ):
			value = _( 'activated' )
		else:
			value = _( 'deactivated' )
		settings.add_row( [ umcd.HTML( '<i>%s</i>' % _( 'Direct access' ) ), value ] )
		rows.append( [ settings ] )

		rows.append( [ umcd.HTML( '<b>%s</b><br>' % _( 'Attached drives' ) ), ] )

		html = '<ul class="umc_listing">'
		for dev in self.drives:
			values = {}
			if dev.device == uvmmp.Disk.DEVICE_DISK:
				values[ 'type' ] = _( 'hard drive' )
			elif dev.device == uvmmp.Disk.DEVICE_CDROM:
				values[ 'type' ] = _( 'CDROM drive' )
			elif dev.device == uvmmp.Disk.DEVICE_FLOPPY:
				values[ 'type' ] = _( 'floppy drive' )
			else:
				values[ 'type' ] = _( 'unknown' )

			if dev.source:
				dir = os.path.dirname(dev.source)
				for pool in self.drive_wizard.storage_pools.values():
					if pool.path == dir:
						values['size'] = MemorySize.num2str(dev.size)
						if len(os.path.basename(dev.source)) > 40:
							values['image'] = xml_escape("%s..." % os.path.basename(dev.source)[0:40])
						else:
							values['image'] = xml_escape(os.path.basename(dev.source))
						values['pool'] = xml_escape(pool.name)
						html += _('<li>%(type)s: %(size)s (image file %(image)s in pool %(pool)s)</li>') % values
						break
				else:
					values['device'] = dev.source
					html += _('<li>%(type)s: local device %(device)s</li>') % values
			else:
				html += _('<li>%(type)s: empty device</li>') % values
		html += '</ul>'
		rows.append( [ umcd.HTML( html ) ] )
		self[InstanceWizard.PAGE_SUMMARY].options[0] = umcd.List( content = rows )
示例#44
0
    def cmd_export(self):
        """USAGE: canto-remote export

    This will print an OPML file to standard output."""

        print("""<opml version="1.0">""")
        print("""\t<body>""")
        for f in self._get_feeds():
            print("""\t\t<outline text="%s" xmlUrl="%s" type="rss" />""" %\
                (xml_escape(f["name"].replace("\"","\\\"")),
                 xml_escape(f["url"])))

        print("""\t</body>""")
        print("""</opml>""")
示例#45
0
def format_lexc_xml(wordmap):
    analysis = xml_escape(wordmap['lemma'])
    analysis = analysis.replace('|',
                                '<s mcs="wb"/>').replace('_', '<s mcs="mb"/>')
    analysis += '<s mcs="' + wordmap['pos'] + '"/>'
    if wordmap['is_proper']:
        analysis += '<s mcs="proper"/>'
    if wordmap['is_suffix']:
        analysis = "<s mcs='suffix'/>" + analysis
    if wordmap['is_prefix']:
        analysis += "<s mcs='prefix'/>"
    stub = xml_escape(wordmap['stub'])
    stub = stub.replace('|', '<s mcs="wb"/>').replace('_', '<s mcs="mb"/>')
    return ('    <e><a>%s</a><i>%s</i><cont lexica="%s"/></e>' %
            (analysis, stub, wordmap['new_para']))
示例#46
0
def get(license_class, locale='en', **kwargs):

    if 'jurisdiction' not in kwargs or not(kwargs['jurisdiction']):
        kwargs['jurisdiction'] = '-'
    
    # generate the answers XML
    answers = "<answers><locale>%s</locale><license-%s>" % (
        locale, license_class.name)

    # get the list of valid fields for this license class
    fields = license_class.kwargs()
    work_info = {}

    for k in kwargs:
        if k in fields:
            answers = answers + "<%s>%s</%s>" % (k, 
                                                 kwargs[k].strip(), 
                                                 k)
        elif k == 'version':
            answers = answers + "<%s>%s</%s>" % (k, str(kwargs[k]), k)
        else:
            work_info[k] = xml_escape(kwargs[k])

    str_work_info = "".join(
        ["<%s>%s</%s>" % (k, work_info[k], k) for k in work_info]
        )

    answers = answers +  "</license-%s><work-info>%s</work-info></answers>" % (
        license_class.name, str_work_info)

    # delegate to the normal issue method
    return issue(answers)
示例#47
0
def _convert_class_to_xml(source, xml_prefix=True):
    if source is None:
        return ''

    xmlstr = ''
    if xml_prefix:
        xmlstr = '<?xml version="1.0" encoding="utf-8"?>'

    if isinstance(source, list):
        for value in source:
            xmlstr += _convert_class_to_xml(value, False)
    elif isinstance(source, WindowsAzureData):
        class_name = source.__class__.__name__
        xmlstr += '<' + class_name + '>'
        for name, value in vars(source).items():
            if value is not None:
                if isinstance(value, list) or \
                    isinstance(value, WindowsAzureData):
                    xmlstr += _convert_class_to_xml(value, False)
                else:
                    xmlstr += ('<' + _get_serialization_name(name) + '>' +
                               xml_escape(str(value)) + '</' +
                               _get_serialization_name(name) + '>')
        xmlstr += '</' + class_name + '>'
    return xmlstr
示例#48
0
 def Browse(self, BrowseFlag, StartingIndex, RequestedCount, ObjectID,
         Filter=None, SortCriteria=None):
     RequestedCount = int(RequestedCount)
     path = self.object_id_to_path(ObjectID)
     if BrowseFlag == 'BrowseDirectChildren':
         children = list(self.list_dlna_dir(path))
         start = int(StartingIndex)
         stop = (start + RequestedCount) if RequestedCount else None
         result_elements = list(thread_pool.map(
             self.object_xml,
             itertools.repeat(ObjectID),
             children[start:stop]))
         total_matches = len(children)
     else: # TODO check other flags
         parent_id = path_to_object_id(os.path.normpath(os.path.split(path)[0]))
         result_elements = [self.object_xml(parent_id, path, '??ROOT??', None)]
         total_matches = 1
     if logging.root.isEnabledFor(logging.DEBUG):
         logging.debug(
             'ContentDirectory::Browse result:\n%s',
             pprint.pformat(result_elements))
     return dict(
         Result=xml_escape(didl_lite(''.join(result_elements))),
         NumberReturned=len(result_elements),
         TotalMatches=total_matches)
示例#49
0
def _cleanOdt(text):
    def compress(spaces):
        return _spaces(len(spaces.group(0)))

    s = xml_escape(text)
    s = re.sub(u" {2,}", compress, s)
    return s
示例#50
0
def _EscapeResourceString(raw_resource):
  if type(raw_resource) == int:
    return raw_resource
  return xml_escape(raw_resource)\
      .replace('\\', '\\\\')\
      .replace('\"','\\\"')\
      .replace('\'','\\\'')
示例#51
0
    def add_from_magnets(self, uris):
        """Add a list of magnet uris to torrent_liststore."""
        already_added = 0

        for uri in uris:
            magnet = deluge.common.get_magnet_info(uri)
            if not magnet:
                log.error('Invalid magnet: %s', uri)
                continue

            torrent_id = magnet['info_hash']
            files = magnet['files_tree']
            if not self._add_torrent_liststore(torrent_id, magnet['name'],
                                               xml_escape(uri), files, None):
                already_added += 1
                continue

            if files:
                continue

            d = client.core.prefetch_magnet_metadata(uri)
            d.addCallback(self._on_uri_metadata, uri)
            self.prefetching_magnets.append(magnet['info_hash'])
            self.prefetch_waiting_message(torrent_id, None)

        if already_added:
            self.show_already_added_dialog(already_added)
示例#52
0
    def GET(self, req):
        """
        Handle GET Service request
        """
        req.query_string = 'format=json'
        resp = req.get_response(self.app)
        status = resp.status_int

        if status != HTTP_OK:
            if status in (HTTP_UNAUTHORIZED, HTTP_FORBIDDEN):
                return get_err_response('AccessDenied')
            else:
                return get_err_response('InvalidURI')

        containers = loads(resp.body)
        # we don't keep the creation time of a backet (s3cmd doesn't
        # work without that) so we use something bogus.
        body = '<?xml version="1.0" encoding="UTF-8"?>' \
               '<ListAllMyBucketsResult ' \
               'xmlns="http://doc.s3.amazonaws.com/2006-03-01">' \
               '<Buckets>%s</Buckets>' \
               '</ListAllMyBucketsResult>' \
               % ("".join(['<Bucket><Name>%s</Name><CreationDate>'
                           '2009-02-03T16:45:09.000Z</CreationDate></Bucket>'
                           % xml_escape(i['name']) for i in containers]))
        return HTTPOk(content_type='application/xml', body=body)
示例#53
0
    def reload_global(self, client, connection_id, entry, data):
        """Unbind all global hotkeys and rebind the show_hide
        method. If more global hotkeys should be added, just connect
        the gconf key to the watch system and add.
        """
        gkey = entry.get_key()
        key = entry.get_value().get_string()

        if key == 'disabled':
            return

        try:
            self.guake.hotkeys.unbind(self.globalhotkeys[gkey])
        except KeyError:
            pass
        self.globalhotkeys[gkey] = key
        if not self.guake.hotkeys.bind(key, self.guake.show_hide):
            keyval, mask = gtk.accelerator_parse(key)
            label = gtk.accelerator_get_label(keyval, mask)
            filename = pixmapfile('guake-notification.png')
            guake.notifier.show_message(
                _('Guake Terminal'),
                _('A problem happened when binding <b>%s</b> key.\n'
                  'Please use Guake Preferences dialog to choose another '
                  'key') % xml_escape(label), filename)
示例#54
0
    def do_list(self, q):
        marker = q.params['marker'][0] if 'marker' in q.params else None
        max_keys = int(q.params['max_keys'][0]) if 'max_keys' in q.params else 1000
        prefix = q.params['prefix'][0] if 'prefix' in q.params else ''

        resp = ['<?xml version="1.0" encoding="UTF-8"?>',
                '<ListBucketResult xmlns="%s">' % self.xml_ns,
                '<MaxKeys>%d</MaxKeys>' % max_keys,
                '<IsTruncated>false</IsTruncated>' ]

        count = 0
        for key in sorted(self.server.data):
            if not key.startswith(prefix):
                continue
            if marker and key <= marker:
                continue
            resp.append('<Contents><Key>%s</Key></Contents>' % xml_escape(key))
            count += 1
            if count == max_keys:
                resp[3] = '<IsTruncated>true</IsTruncated>'
                break

        resp.append('</ListBucketResult>')
        body = '\n'.join(resp).encode()

        self.send_response(200)
        self.send_header("Content-Type", 'text/xml')
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)
示例#55
0
def _convert_class_to_xml(source, xml_prefix=True):
    if source is None:
        return ""

    xmlstr = ""
    if xml_prefix:
        xmlstr = '<?xml version="1.0" encoding="utf-8"?>'

    if isinstance(source, list):
        for value in source:
            xmlstr += _convert_class_to_xml(value, False)
    elif isinstance(source, WindowsAzureData):
        class_name = source.__class__.__name__
        xmlstr += "<" + class_name + ">"
        for name, value in vars(source).iteritems():
            if value is not None:
                if isinstance(value, list) or isinstance(value, WindowsAzureData):
                    xmlstr += _convert_class_to_xml(value, False)
                else:
                    xmlstr += (
                        "<"
                        + _get_serialization_name(name)
                        + ">"
                        + xml_escape(str(value))
                        + "</"
                        + _get_serialization_name(name)
                        + ">"
                    )
        xmlstr += "</" + class_name + ">"
    return xmlstr
示例#56
0
    def GET(self, env, start_response):
        """
        Handle GET Service request
        """
        env['QUERY_STRING'] = 'format=json'
        body_iter = self.app(env, self.do_start_response)
        status = int(self.response_args[0].split()[0])
        headers = dict(self.response_args[1])

        if status != 200:
            if status == 401:
                return get_err_response('AccessDenied')
            else:
                return get_err_response('InvalidURI')

        containers = loads(''.join(list(body_iter)))
        # we don't keep the creation time of a backet (s3cmd doesn't
        # work without that) so we use something bogus.
        body = '<?xml version="1.0" encoding="UTF-8"?>' \
            '<ListAllMyBucketsResult ' \
              'xmlns="http://doc.s3.amazonaws.com/2006-03-01">' \
            '<Buckets>%s</Buckets>' \
            '</ListAllMyBucketsResult>' \
            % ("".join(['<Bucket><Name>%s</Name><CreationDate>' \
                         '2009-02-03T16:45:09.000Z</CreationDate></Bucket>' %
                         xml_escape(i['name']) for i in containers]))
        resp = Response(status=200, content_type='application/xml', body=body)
        return resp