Python flask.Markup类代码示例

def pretty(value):
    if isinstance(value, dict):
        page = markup.page()
        page.ul(_class='dict')
        for k, v in value.items():
            if isinstance(v, list) and v:
                pretty_value = Markup.escape(', '.join(v))
            elif isinstance(v, dict) and v:
                subul = markup.page()
                subul.ul(_class='subdict')
                for subk, subv in v.items():
                    subul.li()
                    subul.span('%s: ' % subk)
                    subul.span(Markup.escape(subv))
                    subul.li.close()
                subul.ul.close()
                pretty_value = subul()
            elif v:
                pretty_value = Markup.escape(v)
            else:
                continue
            page.li()
            page.span('%s:' % k.capitalize().replace('_', ' '))
            page.span(pretty_value)
            page.li.close()
        page.ul.close()
        return page()
    elif isinstance(value, list):
        return Markup.escape(', '.join(value))
    else:
        page = markup.page()
        page.span(Markup.escape(value), _class='simple')
        return page()

def slugify(value, substitutions=()):
    '''
    Normalizes string, converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.

    Took from Django sources.
    '''
    # TODO Maybe steal again from current Django 1.5dev
    value = Markup(value).striptags()
    # value must be unicode per se
    import unicodedata
    from unidecode import unidecode
    # unidecode returns str in Py2 and 3, so in Py2 we have to make
    # it unicode again
    value = unidecode(value)
    if isinstance(value, six.binary_type):
        value = value.decode('ascii')
    # still unicode
    value = unicodedata.normalize('NFKD', value).lower()
    for src, dst in substitutions:
        value = value.replace(src.lower(), dst.lower())
    value = re.sub('[^\w\s-]', '', value).strip()
    value = re.sub('[-\s]+', '-', value)
    # we want only ASCII chars
    value = value.encode('ascii', 'ignore')
    # but Pelican should generally use only unicode
    return value.decode('ascii')

def lists_edit(name=None):
	if 'username' not in session: return goto_login(fname(), fparms())
	action = 'delete' if request.args.get('action', request.form.get('action')) == 'delete' else 'add'
	item = request.args.get('item', request.form.get('item'))
	if not name or not action or not item:
		return redirect(url_for('lists'))
	listname = getattr(userlists, name).printedname
	if request.method == 'POST':
		if name == 'whitelist':
			restartstring = '<span class="halflink" onclick="document.getElementById(\'restartform\').submit();">Restart</span> the server to apply your changes.'
		else:
			restartstring = ''
		if action == 'add':
			if getattr(userlists, name).add(item):
				flash('<i>%s</i> added to %s. %s' % (Markup.escape(item), listname, restartstring), 'success')
			else:
				flash('<i>%s</i> is already in %s.' % (Markup.escape(item), listname), 'info')
		elif action == 'delete':
			if getattr(userlists, name).remove(item):
				flash('<i>%s</i> deleted from %s. %s' % (Markup.escape(item), listname, restartstring), 'success')
			else:
				flash('<i>%s</i> is not in %s.' % (Markup.escape(item), listname), 'info')
		returnpage = request.form.get('returnpage', 'lists')
		return redirect(url_for(returnpage, username=item))
	return render_template('lists_delete.html', navigation=get_navi('lists'), name=name, action=action, item=item, listname=listname)

def new_announcement():
    """Create new announcement."""
    def respond():
        response = dict(template='admin/new_announcement.html',
                        title=gettext("Write a new post"),
                        form=form)
        return handle_content_type(response)

    form = AnnouncementForm()
    del form.id

    # project_sanitized, owner_sanitized = sanitize_project_owner(project, owner, current_user)

    if request.method != 'POST':
        ensure_authorized_to('create', Announcement())
        return respond()

    if not form.validate():
        flash(gettext('Please correct the errors'), 'error')
        return respond()

    announcement = Announcement(title=form.title.data,
                                body=form.body.data,
                                published=form.published.data,
                                media_url=form.media_url.data,
                                user_id=current_user.id)
    ensure_authorized_to('create', announcement)
    announcement_repo.save(announcement)

    msg_1 = gettext('Annnouncement created!')
    markup = Markup('<i class="icon-ok"></i> {}')
    flash(markup.format(msg_1), 'success')

    return redirect_content_type(url_for('admin.announcement'))

def get_killmail_descriptions():
    description = Markup(u"Acceptable Killmail Links:<ul>")
    desc_entry = Markup(u"<li>{}</li>")
    killmail_descs = [desc_entry.format(km.description) for km in\
            current_app.killmail_sources]
    description += Markup(u"").join(killmail_descs)
    description += Markup(u"</ul>")
    return description

def _format_attrs(attrs, escape_attrs=True):
    out = []
    for name, value in sorted(attrs.items()):
        if escape_attrs:
            name = Markup.escape(name)
            value = Markup.escape(value)
        out.append(' {name}="{value}"'.format(name=name, value=value))
    return ''.join(out)

def index():
        li = Markup("""<li><a href="{}">{}</a></li>""")
        results = db.metadata.tables.keys()
        results.sort()
        results = [li.format(url_for("app.view_table", table_name=tbl_name), tbl_name) for tbl_name in results]

        results = Markup("<ul>") + Markup("\n").join(results) + Markup("</ul>")

        return render_template("layout.html", content=results)

 def generate_links(query_list, model=None, model_key=None):
     link = Markup("""<a href="{}">{}</a> - <a href="{}">Delete</a>""")
     model_key = [key.key for key in model_key.columns][0]
     for entry in query_list:
         key = getattr(entry, model_key, 1)
         name = model.__name__
         edit_url = url_for('admin.edit', model_name=name, model_url_key=key)
         delete_url = url_for('admin.delete', model_name=name, model_url_key=key)
         yield link.format(edit_url, entry, delete_url)

def extension_filename(filename,ext):
    '''
    Añade la extension al nombre de archivo
    '''
    fn = Markup(filename).striptags()[:512]
    #si la extension no viene en el nombre se añade
    if ext and not fn.lower().endswith("."+ext.lower()):
        fn = fn+"."+ext
    return fn

def safe_non_valid_input_error(user_input,field_name):
    r"""
    Returns a formatted error message where all non-fixed parameters
    (in particular user input) is escaped.
    """
    msg  = Markup("Error: <span style='color:black'>")+Markup.escape(user_input)
    msg += Markup("</span>")
    msg += Markup(" is not a valid input for <span style='color:black'>")
    msg += Markup.escape(field_name)+Markup("</span>")
    return msg

def test_permissions_custom_word():
  title = 'Testing custom permission, the word should be "yep"'
  data = {
    "app.access('test_permission_word')": app.access('test_permission_word'),
    "app.access('test_permission_word', word='qwer')": app.access('test_permission_word', word='qwer'),
    "app.access('test_permission_word', word='yep')": app.access('test_permission_word', word='yep')
  }
  data = Markup('<br/>').join(["%s: %s" % (k,v) for k,v in data.items()])
  
  return render_template( 'test/index.html', title=title, data=data )

def delete_announcement(id):
    announcement = announcement_repo.get_by(id=id)
    if announcement is None:
        raise abort(404)

    ensure_authorized_to('delete', announcement)
    announcement_repo.delete(announcement)
    msg_1 = gettext('Announcement deleted!')
    markup = Markup('<i class="icon-ok"></i> {}')
    flash(markup.format(msg_1), 'success')
    return redirect_content_type(url_for('admin.announcement'))

def play():
    logged = False
    user_log = ''
    if (session):
        if 'logged_in' not in session:
            return redirect(url_for('login'))
        else:
            if session['logged_in']:
                logged = True
                user_log = Markup('<a class="nav-link" href="/profile"> Hello, {0} </a>'.format(session['user_name']))
            else:
                return redirect(url_for('login'))
    else:
        return redirect(url_for('login'))

    difficulty = request.args.get("diff")
    song_id = request.args.get("sg")
    if not song_id or not difficulty:
        # display error page
        pass
    song = get_song_details(song_id)
    word_list = get_words_to_hide(song_id, int(difficulty))
    song_tags = get_tags_for_song(song_id)
    lyrics = song.lyrics.replace('\n', '<br>')
    html_to_replace = Markup('<div class="form-group"> \
                                <div class="input-group"> \
                                    <input type="text" id="{0}" class="missing-word form-control" size="{1}" maxlength="{1}" data-word="{3}"> \
                                    <span class="glyphicon glyphicon-eye-open input-group-addon" data-toggle="tooltip" data-placement="bottom" aria-hidden="true" title="{2}"> \
                                          </span> \
                                </div> \
                      </div>')
    i = 0
    for word in word_list:
        hint = get_hint_for_word(word, int(difficulty))
        lyrics, k = re.subn(r'\s({0})\s'.format(word),
                            html_to_replace.format("word-{0}".format(i), len(word) + 1, hint, word),
                            lyrics, count=max([1, int(difficulty) - 1]))
        i += k

    m, s = divmod(int(song.length), 60)
    song_duration = "%02d:%02d" % (m, s)
    video_url = song.video_url[song.video_url.index('v=') + 2:]
    keep_ids, _ = get_user_keep(session['user_id'])
    keep_next = get_next_keep(session['user_id'], song_id)
    keep_count = get_keep_count_for_song(song_id)
    play_count = get_play_count_for_song(song_id)

    return render_template('play.html', logged_in=logged, profile_login=user_log, user_id=session['user_id'],
                           song_id=song_id, lyrics=lyrics,
                           song_tags=song_tags, song_artist=song.artist,
                           song_title=song.title, release_year=song.release_year, song_duration=song_duration,
                           video_url=video_url, num_of_words=i, difficulty=int(difficulty),
                           keep_ids=keep_ids, keep_next=keep_next, keep_count=keep_count, play_count=play_count)

def add_new_language():
    user = fetch_id_from_userid(current_user.id)
    bcp = request.args.get('bcp', None)
    bcp = str(Markup.escape(bcp))
    iso = request.args.get('iso', None)
    iso = str(Markup.escape(iso))
    name = request.args.get('name', None)
    name = str(Markup.escape(name))
    if bcp and name:
        dbinsert = insert_new_language(bcp, iso, name, user)
        return jsonify(result=dbinsert)
    else:
        return jsonify(result=False)

 def handle_starttag(self, tag, attrs):
     self.container.append("<%s>" % tag)
     attrs_string = ''
     if attrs:
         for attr in attrs:
             str = '%s="%s" ' % (attr[0], attr[1])
             attrs_string = attrs_string + str
         if attrs_string and attrs_string[-1] == " ":
             attrs_string = attrs_string[:-1]
         tag_string =  Markup.escape('<%s %s>' % (tag, attrs_string))
     else:
         tag_string = Markup.escape('<%s>' % tag)
     self.div_wrap = self.div_wrap + Markup('<span class="slack-%s">' % tag) + \
                     tag_string + Markup('</span>')