def render_map():
css_js = ''
if conf.LOAD_CUSTOM_CSS_FILE:
css_js = '<link rel="stylesheet" href="static/css/custom.css">'
if conf.LOAD_CUSTOM_JS_FILE:
css_js += '<script type="text/javascript" src="static/js/custom.js"></script>'
js_vars = Markup(
"_defaultSettings['FIXED_OPACITY'] = '{:d}'; "
"_defaultSettings['SHOW_TIMER'] = '{:d}'; "
"_defaultSettings['TRASH_IDS'] = [{}]; ".format(conf.FIXED_OPACITY, conf.SHOW_TIMER, ', '.join(str(p_id) for p_id in conf.TRASH_IDS)))
template = env.get_template('custom.html' if conf.LOAD_CUSTOM_HTML_FILE else 'newmap.html')
return html(template.render(
area_name=conf.AREA_NAME,
map_center=center,
map_provider_url=conf.MAP_PROVIDER_URL,
map_provider_attribution=conf.MAP_PROVIDER_ATTRIBUTION,
social_links=social_links(),
init_js_vars=js_vars,
extra_css_js=Markup(css_js)
))
python类Markup()的实例源码
def locale_(plugin_id, s):
""" Search the plugin that's rendering the template
for the requested locale """
if plugin_id == 'prism':
ns = prism.settings.PRISM_LOCALE[s]
else:
plugin = prism.get_plugin(plugin_id)
if plugin is None:
logging.output('Unknown plugin ID. Offender: %s' % plugin_id)
return s
ns = plugin.locale[s]
if s == ns:
return s
ns = publish_string(ns, writer=html_fragment_writer).decode('utf-8').rstrip('\r\n')
if '<p>' not in ns:
return ''
ns = ns.split('<p>', 1)[1]
ns = ns[:ns.rfind('</p>')]
return jinja2.Markup(ns)
def repo_link(repo, show_secret=False):
"""Convert repo to link to the detail page of that repo
:param repo: Repository to show its link
:type repo: ``repocribro.models.Repository``
:param show_secret: If secret links should be returned
:type show_secret: bool
:return: HTML code with link to repository detail page
:rtype: ``jinja2.Markup``
"""
url = None
if repo.is_public:
url = flask.url_for('core.repo_detail',
login=repo.owner_login, reponame=repo.name)
elif repo.is_hidden and show_secret:
url = flask.url_for('core.repo_detail_hidden', secret=repo.secret)
elif repo.is_private and show_secret:
url = flask.url_for('core.repo_detail',
login=repo.owner_login, reponame=repo.name)
if url is None:
return 'Top secret'
return jinja2.Markup('<a href="{0}">{0}</a>'.format(url))
def test_repo_link():
repo = Repository(777, None, 'some/project', 'project', 'C++', '', '',
False, None, None, Repository.VISIBILITY_PUBLIC)
result = repo_link(repo, False)
assert 'a href="' in result
assert isinstance(result, jinja2.Markup)
result = repo_link(repo, True)
assert 'a href="' in result
assert isinstance(result, jinja2.Markup)
repo.visibility_type = Repository.VISIBILITY_HIDDEN
repo.generate_secret()
result = repo_link(repo, False)
assert 'a href="' not in result
result = repo_link(repo, True)
assert 'a href="' in result
assert repo.secret in result
assert repo.name not in result
assert repo.owner_login not in result
assert isinstance(result, jinja2.Markup)
repo.visibility_type = Repository.VISIBILITY_PRIVATE
result = repo_link(repo, False)
assert 'a href="' not in result
result = repo_link(repo, True)
assert 'a href="' in result
assert isinstance(result, jinja2.Markup)
def hidden_tag(self, *fields):
"""
Wraps hidden fields in a hidden DIV tag, in order to keep XHTML
compliance.
.. versionadded:: 0.3
:param fields: list of hidden field names. If not provided will render
all hidden fields, including the CSRF field.
"""
if not fields:
fields = [f for f in self if _is_hidden(f)]
rv = [u'<div style="display:none;">']
for field in fields:
if isinstance(field, string_types):
field = getattr(self, field)
rv.append(text_type(field))
rv.append(u"</div>")
return Markup(u"".join(rv))
def include_moment(version = '2.3.1'):
if version is not None:
if request.is_secure:
protocol = 'https'
else:
protocol = 'http'
js = '<script src="%s://cdnjs.cloudflare.com/ajax/libs/moment.js/%s/moment-with-langs.min.js"></script>\n' % (protocol, version)
return Markup('''%s<script>
function flask_moment_render(elem) {
$(elem).text(eval('moment("' + $(elem).data('timestamp') + '").' + $(elem).data('format') + ';'));
$(elem).removeClass('flask-moment');
}
function flask_moment_render_all() {
$('.flask-moment').each(function() {
flask_moment_render(this);
if ($(this).data('refresh')) {
(function(elem, interval) { setInterval(function() { flask_moment_render(elem) }, interval); })(this, $(this).data('refresh'));
}
})
}
$(document).ready(function() {
flask_moment_render_all();
});
</script>''' % js)
def hidden_tag(self, *fields):
"""
Wraps hidden fields in a hidden DIV tag, in order to keep XHTML
compliance.
.. versionadded:: 0.3
:param fields: list of hidden field names. If not provided will render
all hidden fields, including the CSRF field.
"""
if not fields:
fields = [f for f in self if _is_hidden(f)]
rv = [u'<div style="display:none;">']
for field in fields:
if isinstance(field, string_types):
field = getattr(self, field)
rv.append(text_type(field))
rv.append(u"</div>")
return Markup(u"".join(rv))
def include_moment(version='2.5.1', local_js=None):
js = ''
if local_js is not None:
js = '<script src="%s"></script>\n' % local_js
elif version is not None:
js = '<script src="//cdnjs.cloudflare.com/ajax/libs/' \
'moment.js/%s/moment-with-langs.min.js"></script>\n' % version
return Markup('''%s<script>
function flask_moment_render(elem) {
$(elem).text(eval('moment("' + $(elem).data('timestamp') + '").' + $(elem).data('format') + ';'));
$(elem).removeClass('flask-moment');
}
function flask_moment_render_all() {
$('.flask-moment').each(function() {
flask_moment_render(this);
if ($(this).data('refresh')) {
(function(elem, interval) { setInterval(function() { flask_moment_render(elem) }, interval); })(this, $(this).data('refresh'));
}
})
}
$(document).ready(function() {
flask_moment_render_all();
});
</script>''' % js)
def format_instrumented_list(view, context, model, name):
value = getattr(model, name)
out = ""
if isinstance(value, InstrumentedList):
out = "<ul>"
for x in value:
if x is None:
continue
if hasattr(x, "admin_view_link"):
out += "<li><a href='{}'>{}</a></li>".format(
getattr(x, "admin_view_link")(), x)
else:
out += str(x)
out += "</ul>"
return Markup(out)
def format_tasks(view, context, model, name):
value = getattr(model, name)
out = ""
if isinstance(value, InstrumentedList):
out = "<ul>"
for task in value:
task_formatted = "<a href={}>{}</a>".format(
task.admin_view_link(), task)
if task.assignee is not None:
task_formatted += " assigned to <a href='{}'>{}</a> ".format(
task.assignee.admin_view_link(), str(task.assignee))
else:
task_formatted += " not assigned "
task_formatted += " (Updated at: {} )".format(
task.updated_at.strftime("%Y-%m-%d"))
out += "<li>{}</li>".format(task_formatted)
out += "</ul>"
return Markup(out)
def format_messages(view, context, model, name):
value = getattr(model, name)
out = "<ul>"
if isinstance(value, InstrumentedList):
for x in value:
if hasattr(x, "admin_view_link"):
out += "<li>({authorname}/{messagetitle}/{createdate}) wrote: <br/> {messagecontent}<a href='{messageadminlink}'> Read more...</a></li>".format(
authorname=str(x.user),
messagetitle=x.title,
createdate=str(x.created_at_short),
messageadminlink=getattr(x, "admin_view_link")(),
messagecontent=x.content)
else:
out += str(x)
out += "</ul>"
return Markup(out)
def hidden_tag(self, *fields):
"""
Wraps hidden fields in a hidden DIV tag, in order to keep XHTML
compliance.
.. versionadded:: 0.3
:param fields: list of hidden field names. If not provided will render
all hidden fields, including the CSRF field.
"""
if not fields:
fields = [f for f in self if _is_hidden(f)]
rv = [u'<div style="display:none;">']
for field in fields:
if isinstance(field, string_types):
field = getattr(self, field)
rv.append(text_type(field))
rv.append(u"</div>")
return Markup(u"".join(rv))
def include_moment(version = '2.3.1'):
if version is not None:
js = '<script src="http://cdnjs.cloudflare.com/ajax/libs/moment.js/%s/moment-with-langs.min.js"></script>\n' % version
return Markup('''%s<script>
function flask_moment_render(elem) {
$(elem).text(eval('moment("' + $(elem).data('timestamp') + '").' + $(elem).data('format') + ';'));
$(elem).removeClass('flask-moment');
}
function flask_moment_render_all() {
$('.flask-moment').each(function() {
flask_moment_render(this);
if ($(this).data('refresh')) {
(function(elem, interval) { setInterval(function() { flask_moment_render(elem) }, interval); })(this, $(this).data('refresh'));
}
})
}
$(document).ready(function() {
flask_moment_render_all();
});
</script>''' % js)
def get_assets(asset_type):
path = os.path.join(current_app.root_path, current_app.config['TEMPLATE_FOLDER'], 'assets.json')
assets = json.load(open(path, 'r'))
output = ''
if asset_type == 'css':
output = '<link rel="stylesheet" href="{0}">'.format(assets['style']['css'])
elif asset_type == 'js':
manifest = assets['manifest']['js']
manifest = manifest[1:]
manifest_file = open(os.path.join(current_app.root_path, current_app.config['STATIC_FOLDER'], manifest), 'r')
output += '<script>' + manifest_file.read() + '</script>'
manifest_file.close()
output += '<script src="{0}"></script>'.format(assets['vendor']['js'])
output += '<script src="{0}"></script>'.format(assets['app']['js'])
return jinja2.Markup(output)
def wikirender(eval_ctx, wikicode):
"""
Converts wikicode to the resulting HTML
"""
r = requests.get('https://en.wikipedia.org/w/api.php',
{'action':'parse',
'text':wikicode,
'format':'json',
})
result = r.json().get('parse',{}).get('text', {}).get('*','')
result = result.replace('href="/wiki/',
'href="https://en.wikipedia.org/wiki/')
result = result.replace('<a ','<a target="_blank" ')
if eval_ctx.autoescape:
result = Markup(result) or wikicode
return result or wikicode
def include_moment(version = '2.3.1'):
if version is not None:
if request.is_secure:
protocol = 'https'
else:
protocol = 'http'
js = '<script src="%s://cdnjs.cloudflare.com/ajax/libs/moment.js/%s/moment-with-langs.min.js"></script>\n' % (protocol, version)
return Markup('''%s<script>
function flask_moment_render(elem) {
$(elem).text(eval('moment("' + $(elem).data('timestamp') + '").' + $(elem).data('format') + ';'));
$(elem).removeClass('flask-moment');
}
function flask_moment_render_all() {
$('.flask-moment').each(function() {
flask_moment_render(this);
if ($(this).data('refresh')) {
(function(elem, interval) { setInterval(function() { flask_moment_render(elem) }, interval); })(this, $(this).data('refresh'));
}
})
}
$(document).ready(function() {
flask_moment_render_all();
});
</script>''' % js)
def location_schema_html(self):
html = [
'<span itemscope itemprop="location" itemtype="http://schema.org/Place">',
' <meta itemprop="name" content="%s" />' % self.actual_city_name,
' <meta itemprop="address" content="%s" />' % self.actual_city_name,
]
if self.latitude:
html += [
' <span itemprop="geo" itemscope itemtype="http://schema.org/GeoCoordinates">',
' <meta itemprop="latitude" content="%s" />' % self.latitude,
' <meta itemprop="longitude" content="%s" />' % self.longitude,
' </span>',
]
html += [
'</span>',
]
return jinja2.Markup('\n'.join(html))
def status_filter(eval_ctx, status):
"""
Format a status.
"""
result = None
if status:
if status.lower() == 'green':
result = '<p class="text-success">{}</p>'.format(status)
if status.lower() == 'yellow':
result = '<p class="text-warning">{}</p>'.format(status)
if status.lower() == 'red':
result = '<p class="text-danger">{}</p>'.format(status)
if result:
if eval_ctx.autoescape:
return Markup(result)
else:
return result
return status
# Task
def test_f_markup():
format_string = 'Hello <b>{0}</b>'
format_markup = Markup(format_string)
val_string = '<em>Steve</em>'
val_markup = Markup(val_string)
template = '{{ fmt|f(val) }}'
expect = 'Hello <b><em>Steve</em></b>'
combinations = (
(format_string, val_string),
(format_string, val_markup),
(format_markup, val_string),
(format_markup, val_markup),
)
def _check(f, v):
s = render(template, {'fmt': f, 'val': v})
eq_(expect, s)
for f, v in combinations:
yield _check, f, v
def test_fe_markup():
format_string = 'Hello <b>{0}</b>'
format_markup = Markup(format_string)
val_string = '<em>Steve</em>'
val_markup = Markup(val_string)
template = '{{ fmt|fe(val) }}'
expect_esc = 'Hello <b><em>Steve</em></b>'
expect_noesc = 'Hello <b><em>Steve</em></b>'
combinations = (
(format_string, val_string, expect_esc),
(format_string, val_markup, expect_noesc),
(format_markup, val_string, expect_esc),
(format_markup, val_markup, expect_noesc),
)
def _check(f, v, e):
s = render(template, {'fmt': f, 'val': v})
eq_(e, s)
for f, v, e in combinations:
yield _check, f, v, e
def tojson_filter(obj, **kwargs):
return Markup(htmlsafe_dumps(obj, **kwargs))
def tojson_filter(obj, **kwargs):
return Markup(htmlsafe_dumps(obj, **kwargs))
def convert_markdown(text):
text = textwrap.dedent(text)
result = jinja2.Markup(markdown.markdown(text, extensions=['markdown.extensions.fenced_code']))
return result
def tojson_filter(obj, **kwargs):
return Markup(htmlsafe_dumps(obj, **kwargs))
def hidden_tag(self, *fields):
"""Render the form's hidden fields in one call.
A field is considered hidden if it uses the
:class:`~wtforms.widgets.HiddenInput` widget.
If ``fields`` are given, only render the given fields that
are hidden. If a string is passed, render the field with that
name if it exists.
.. versionchanged:: 0.13
No longer wraps inputs in hidden div.
This is valid HTML 5.
.. versionchanged:: 0.13
Skip passed fields that aren't hidden.
Skip passed names that don't exist.
"""
def hidden_fields(fields):
for f in fields:
if isinstance(f, string_types):
f = getattr(self, f, None)
if f is None or not isinstance(f.widget, HiddenInput):
continue
yield f
return Markup(
u'\n'.join(text_type(f) for f in hidden_fields(fields or self))
)
def tojson_filter(obj, **kwargs):
return Markup(htmlsafe_dumps(obj, **kwargs))
def hidden_tag(self, *fields):
"""Render the form's hidden fields in one call.
A field is considered hidden if it uses the
:class:`~wtforms.widgets.HiddenInput` widget.
If ``fields`` are given, only render the given fields that
are hidden. If a string is passed, render the field with that
name if it exists.
.. versionchanged:: 0.13
No longer wraps inputs in hidden div.
This is valid HTML 5.
.. versionchanged:: 0.13
Skip passed fields that aren't hidden.
Skip passed names that don't exist.
"""
def hidden_fields(fields):
for f in fields:
if isinstance(f, string_types):
f = getattr(self, f, None)
if f is None or not isinstance(f.widget, HiddenInput):
continue
yield f
return Markup(
u'\n'.join(text_type(f) for f in hidden_fields(fields or self))
)
def tojson_filter(obj, **kwargs):
return Markup(htmlsafe_dumps(obj, **kwargs))
def render(self, format):
return Markup("<script>\ndocument.write(moment(\"%s\").%s);\n</script>" % (
self.timestamp.strftime( "%Y-%m-%dT%H:%M:%S" ), format))
def nl2br(eval_ctx, value):
result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', '<br>\n') \
for p in _paragraph_re.split(escape(value)))
if eval_ctx.autoescape:
result = Markup(result)
return result
