def render(value):
return Markup(self.render_markdown(value))
def create_product_list(asin_list, review_score_dict, query, age_list,
occasion_list):
product_list = []
for asin in asin_list:
row = metadata_df.loc[metadata_df.asin == asin]
reviews = reviews_df.loc[reviews_df.asin == asin]
if (not row.empty):
title = str(row['title'].iloc[0])
if asin in review_score_dict:
review_scores = review_score_dict[asin]
review_score_sorted = {
k: v
for k, v in sorted(review_scores.items(),
key=lambda item: item[1],
reverse=True)
}
reviewerIDs = list(review_score_sorted.keys())[:2]
if (len(reviewerIDs) >= 2):
review1 = str(
reviews.loc[reviews['reviewerID'] ==
reviewerIDs[0]].iloc[0]['reviewText'])
review2 = str(
reviews.loc[reviews['reviewerID'] ==
reviewerIDs[1]].iloc[0]['reviewText'])
summary1 = str(
reviews.loc[reviews['reviewerID'] ==
reviewerIDs[0]].iloc[0]['summary'])
summary2 = str(
reviews.loc[reviews['reviewerID'] ==
reviewerIDs[1]].iloc[0]['summary'])
if (len(reviewerIDs) == 1):
review1 = str(
reviews.loc[reviews['reviewerID'] ==
reviewerIDs[0]].iloc[0]['reviewText'])
summary1 = str(
reviews.loc[reviews['reviewerID'] ==
reviewerIDs[0]].iloc[0]['summary'])
review2 = ""
summary2 = ""
else:
review1 = str(reviews['reviewText'].iloc[0])
review2 = str(reviews['reviewText'].iloc[1])
summary1 = str(reviews['summary'].iloc[0])
summary2 = str(reviews['summary'].iloc[1])
else:
review1 = str(reviews['reviewText'].iloc[0])
review2 = str(reviews['reviewText'].iloc[1])
summary1 = str(reviews['summary'].iloc[0])
summary2 = str(reviews['summary'].iloc[1])
image = str(row['image'].iloc[0])
out_price = '$' + str(row['price'].iloc[0])
review1, review2 = highlight(query, age_list, occasion_list,
review1, review2)
# if (float(row['price'].iloc[0]) <= price):
# if(float(row['price'].iloc[0]) <= max_price and float(row['price'].iloc[0]) >= min_price):
product_tuple = (asin, title, summary1, summary2, Markup(review1),
Markup(review2), image, out_price)
product_list.append(product_tuple)
# list of tuples
return product_list
def plain(repo, ref, path, entry):
data = escape(decode(entry.to_object().data))
data = re.sub(
r'(https?://(?:[-a-zA-Z0-9\._~:/?#\[\]@!\'()*+,;=]+|&)+)',
Markup(r'<a href="\1">\1</a>'), data)
return Markup(u"<pre>%s</pre>" % data)
def render(self):
return Markup(u'\n'.join(
chain(*[getattr(self, 'render_' + name)()
for name in MEDIA_TYPES])))
def _urlencode(self, s):
if type(s) == 'Markup':
s = s.unescape()
return Markup(urllib.quote_plus(s.encode('utf-8')))
def _add_item_to_the_feed(self, feed, item):
"""Performs an 'in-place' update of existing 'published' articles
in ``feed`` by creating a new entry using the contents from the
``item`` being passed.
This method is invoked by pelican's core.
:param feed: An PodcastFeed instance.
:param item: An article (pelican's Article object).
"""
# Local copy of iTunes attributes to add to the feed.
items = DEFAULT_ITEM_ELEMENTS.copy()
# Link to the new article.
# http://example.com/episode-01
items['link'] = '{0}/{1}'.format(self.site_url, item.url)
# Title for the article.
# ex: <title>Episode Title</title>
items['title'] = Markup(item.title).striptags()
# Summary for the article. This can be obtained either from
# a ``:description:`` or a ``:summary:`` directive.
# ex: <itunes:summary>In this episode... </itunes:summary>
if hasattr(item, 'description'):
items['itunes:summary'] = item.description
else:
items['itunes:summary'] = Markup(item.summary).striptags()
items['description'] = items['itunes:summary']
# Date the article was last modified.
# ex: <pubDate>Fri, 13 Jun 2014 04:59:00 -0300</pubDate>
items['pubDate'] = rfc2822_date(
set_date_tzinfo(
item.modified if hasattr(item, 'modified') else item.date,
self.settings.get('TIMEZONE', None)))
# Name(s) for the article's author(s).
# ex: <itunes:author>John Doe</itunes:author>
if hasattr(item, 'author'):
items['itunes:author'] = item.author.name
# Subtitle for the article.
# ex: <itunes:subtitle>My episode subtitle</itunes:subtitle>
if hasattr(item, 'subtitle'):
items['itunes:subtitle'] = Markup(item.subtitle).striptags()
# Ex:
# <itunes:image href="http://example.com/Episodio1.jpg" />
if hasattr(item, 'image'):
items['itunes:image'] = {
'href': '{0}{1}'.format(self.site_url, item.image)
}
# Information about the episode audio.
# ex: <enclosure url="http://example.com/episode.m4a"
# length="872731" type="audio/x-m4a" />
if hasattr(item, 'podcast'):
enclosure = {'url': item.podcast}
# Include the file size if available.
if hasattr(item, 'length'):
enclosure['length'] = item.length
# Include the audio mime type if available...
if hasattr(item, 'mimetype'):
enclosure['type'] = item.mimetype
else:
# ... or default to 'audio/mpeg'.
enclosure['type'] = 'audio/mpeg'
items['enclosure'] = enclosure
# Duration for the audio file.
# <itunes:duration>7:04</itunes:duration>
if hasattr(item, 'duration'):
items['itunes:duration'] = item.duration
# Unique identifier for the episode.
# Use a 'guid' if available...
# ex: <guid>http://example.com/aae20050615.m4a</guid>
if hasattr(item, 'guid'):
items['guid'] = item.guid
# ... else, use the article's link instead.
# ex: <guid>http://example.com/episode-01</guid>
else:
items['guid'] = items['link']
# Add the new article to the feed.
feed.add_item(**items)
def nl2br(value):
if not value:
return ""
result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', Markup('<br>\n'))
for p in _paragraph_re.split(escape(value.strip())))
return Markup(result)
def public_email(email):
"""Email address -> publicly displayable email."""
return Markup('<span class="email">%s</span>' % unicode_to_html(email))
def private_message(user):
"""Return a link to private message the user."""
url = urlparams(reverse('messages.new'), to=user.username)
msg = _('Private message')
return Markup(u'<p class="pm"><a href="{url}">{msg}</a></p>'.format(
url=url, msg=msg))
def render_embed(self):
"""
Produce rendered charts in html for embedding purpose
"""
return Markup("<br/> ".join([chart.render_embed() for chart in self]))
def get_code():
return dict(recaptcha=Markup(self.get_code()))
def include():
js_path = url_for('serve_js')
return Markup('<script src="%s" type="text/javascript"></script>') % (
js_path, )
def __init__(self, isbn, name):
self.name = name
self.cover = isbnlib.cover(isbn)['thumbnail']
self.description = isbnlib.desc(isbn)
self.description = self.description.replace('\n', '<br>')
self.description = Markup(self.description)
def anchor_here(s):
return Markup('<div id="-{}"></div>'.format(uri_fragment(s)))
def simple():
c = bar_base()
return Markup(c.render_embed())
def format_markdown(text):
html = markdown_processor.convert(text)
html = cleaner.clean_html(html)
return Markup(html)
def render_dashboard(new_user=False,
new_team=False,
set_team=False,
form=None):
"""
Render dashboard screen.
:return:
"""
if new_user:
if form is None:
form = set_role_form_choices_validators(RoleForm())
# Create user in database, on submit.
submit_action = url_for('setup_user')
submit_text = "Create"
elif new_team:
if form is None:
form = NewTeamForm()
# Create manager's team in database, on submit.
submit_action = url_for('setup_team_ui')
submit_text = "Create"
elif set_team:
if form is None:
form = set_team_form_choices_validators(SetTeamForm())
# Set player's team in database, on submit.
submit_action = url_for('set_user_team', user_id=get_profile_db_id())
submit_text = "Set"
else:
# Basic dashboard.
form = None
submit_action = None
submit_text = None
# Show messages for unconfirmed match selections.
db_id = get_profile_db_id()
for match in get_selected_and_unconfirmed(db_id):
url = url_for('match_selections', match_id=match.id)
opposition = get_team_name(
pick_by_home_id(match, M_AWAY_ID, M_HOME_ID))
flash(
Markup(
f'<div>'
f'You have not confirmed availability for '
f'{match[M_START_TIME].strftime(APP_DATETIME_FMT)} '
f'{choose_by_home_id(match[M_HOME_ID], "home", "away")} '
f'match versus {opposition}.'
f'</div>'
f'<div>'
f'<a class="btn btn-default btn-sm" href="{url}">'
f'<i class="fas fa-edit" data-bs-toggle="tooltip" '
f'data-bs-placement="top" title="Confirm availability"></i>'
f'</a>'
f'</div>'))
return render_template(
'dashboard.html',
new_user=new_user,
new_team=new_team,
set_team=set_team,
form=form,
submit_action=submit_action,
submit_text=submit_text,
userinfo_pretty=json_encoder.encode(get_jwt_payload()),
last_login=local_datetime(
get_jwt_payload_updated_at()).strftime(APP_DATETIME_FMT),
title="Dashboard")
def render(self, format):
return Markup(
"<script>\ndocument.write(moment(\"%s\").%s);\n</script>" %
(self.timestamp.strftime("%Y-%m-%dT%H:%M:%S Z"), format))
def test_markup_and_chainable_undefined(self):
from jinja2 import Markup
from jinja2.runtime import ChainableUndefined
assert str(Markup(ChainableUndefined())) == ""
def regulation_results_page(self, request):
all_regs = Part.objects.order_by('part_number')
regs = validate_regs_list(request)
order = validate_order(request)
search_query = request.GET.get('q', '').strip()
payload = {
'search_query': search_query,
'results': [],
'total_results': 0,
'regs': regs,
'all_regs': [],
}
if not search_query or len(urllib.parse.unquote(search_query)) == 1:
self.results = payload
return TemplateResponse(request, self.get_template(request),
self.get_context(request))
search = SectionParagraphDocument.search().query('match',
text={
"query":
search_query,
"operator": "AND"
})
search = search.highlight('text',
pre_tags="<strong>",
post_tags="</strong>")
total_results = search.count()
all_regs = [{
'short_name':
reg.short_name,
'id':
reg.part_number,
'num_results':
search.filter('term', part=reg.part_number).count(),
'selected':
reg.part_number in regs
} for reg in all_regs]
payload.update({'all_regs': all_regs, 'total_count': total_results})
if regs:
search = search.filter('terms', part=regs)
if order == 'regulation':
search = search.sort('part', 'section_order')
search = search[0:total_results]
response = search.execute()
for hit in response[0:total_results]:
try:
snippet = Markup("".join(hit.meta.highlight.text[0]))
except TypeError as e:
logger.warning(
"Query string {} produced a TypeError: {}".format(
search_query, e))
continue
hit_payload = {
'id':
hit.paragraph_id,
'part':
hit.part,
'reg':
hit.short_name,
'label':
hit.title,
'snippet':
snippet,
'url':
"{}{}/{}/#{}".format(self.parent().url, hit.part,
hit.section_label, hit.paragraph_id),
}
payload['results'].append(hit_payload)
payload.update({'current_count': search.count()})
self.results = payload
context = self.get_context(request)
num_results = validate_num_results(request)
paginator = Paginator(payload['results'], num_results)
page_number = validate_page_number(request, paginator)
paginated_page = paginator.page(page_number)
context.update({
'current_count':
payload['current_count'],
'total_count':
payload['total_count'],
'paginator':
paginator,
'current_page':
page_number,
'num_results':
num_results,
'order':
order,
'results':
paginated_page,
'show_filters':
any(reg['selected'] is True for reg in payload['all_regs'])
})
return TemplateResponse(request, self.get_template(request), context)
def em(text):
return Markup("<em>{}</em>").format(text)
def format_json(self, value):
return Markup(json.dumps(value, sort_keys=True).strip())
def __call__(self, field, **kwargs):
if request.method == 'POST':
area_value = request.form.get(field.name, '')
netloc_value = request.form.get(field.name + '_netloc', '')
selected_value = request.form.get(field.name + '_selected', '')
else:
area_value = request.args.get(field.name, '')
netloc_value = request.args.get(field.name + '_netloc', '')
selected_value = request.args.get(field.name + '_selected', '')
if hasattr(field.data, 'get') and area_value == '':
area_value = field.data.get('area_value')
netloc_value = field.data.get('netloc_value')
selected_value = field.data.get('selected_value')
if area_value == '':
area_value_chosen = u'请选择区域'
else:
area_value_chosen = area_value
html = u'''
<script type="text/javascript">
$(function(){
var config = {
replace_search_input: function(){
return '<div id="tree" style="height: 150px;"></div>'
}
};
$("#%(field_id)s_chosen").chosen(config);
$("#tree").dynatree({
checkbox: true,
selectMode: %(select_mode)s,
imagePath: '',
initAjax:{
url:"/area_select",
data:{
selected_ids: $('#%(field_id)s_selected').val()
}
},
onActivate: function(dtnode) {},
onLazyRead: function(dtnode){
dtnode.appendAjax({
url:"/area_select",
data:{
key: dtnode.data.key,
selected_ids: $('#%(field_id)s_selected').val()
}
});
},
onSelect: function(select, dtnode) {
var selNodes = dtnode.tree.getSelectedNodes();
var selkeys = [];
var selTitles = [];
var selvals = $.map(selNodes, function(node){
selkeys.push(node.data.key);
selTitles.push(node.data.title);
return node.data.area_type + '=' + node.data.key;
});
$("#%(field_id)s_netloc").val(selvals.join(" or "));
$("#%(field_id)s_selected").val(selkeys.join(","));
$("#%(field_id)s").val(selTitles.join(","));
if(selTitles == "") {
$("a.chzn-single.chzn-default span").html("请选择区域");
}else {
$("a.chzn-single.chzn-default span").html(selTitles.join(","));
}
},
strings: {
loading: "加载中…",
loadError: "加载错误!"
},
onKeydown: function(dtnode, event) {
if( event.which == 13 ) {
dtnode.toggleSelect();
return false;
}
}
});
$("a.chzn-single.chzn-default span").html("%(area_value_chosen)s");
});
</script>
<select id="%(field_id)s_chosen"></select>
<input id="%(field_id)s" type="hidden" name="%(field_name)s" value="%(area_value)s" />
<input id="%(field_id)s_netloc" type="hidden" value="%(netloc_value)s" name="%(field_name)s_netloc" />
<input id="%(field_id)s_selected" type="hidden" value="%(selected_value)s" name="%(field_name)s_selected" />
''' % {
'select_mode': field.select_mode,
'field_id': field.id,
'field_name': field.name,
'area_value': area_value,
'area_value_chosen': area_value_chosen,
'netloc_value': netloc_value,
'selected_value': selected_value
}
return Markup(html)
def format_yaml(self, value):
return Markup(yaml.dump(value, default_flow_style=True,
Dumper=OrderedDictDumper).strip())
def _safe(self, s):
if type(s) == 'Markup':
return s.unescape()
else:
return Markup(s).unescape()
def format_python(self, value):
return Markup(pprint.pformat(value).strip())
link2 = url_for('commit', repo=repo.name, ref=commit['hex'])
blame[-1] = commit['hex']
return Markup(
'<a href="%s" title="%s (%s)">%s</a> %s<a href="%s#l-%s">%s</a>'
% (link2, commit['summary'],
time.strftime(
'%Y-%m-%d', time.gmtime(int(
commit['committer-time']))), commit['hex'][:7],
match.group(1), link, orig_line, match.group(2)))
html = re.sub(r'(<a name="l-(\d+)"></a><span class="[^"]+">\s*)(\d+)',
replace, html)
return html
add_plain_link = Markup(
'''<script type="text/javascript">add_plain_link()</script>''')
@renderer
def markdown(repo, ref, path, entry):
data = decode(entry.to_object().data)
return Markup(
markdown_.Markdown(safe_mode="escape").convert(data)) + add_plain_link
@renderer
def rest(repo, ref, path, entry):
data = decode(entry.to_object().data)
settings = {
'file_insertion_enabled': False,
'raw_enabled': False,
def _render(self, csrf_token):
from django.template.defaulttags import CsrfTokenNode
return Markup(CsrfTokenNode().render({'csrf_token': csrf_token}))
def markdown(repo, ref, path, entry):
data = decode(entry.to_object().data)
return Markup(
markdown_.Markdown(safe_mode="escape").convert(data)) + add_plain_link
def _add_item_to_the_feed(self, feed, item):
"""Performs an 'in-place' update of existing 'published' articles
in ``feed`` by creating a new entry using the contents from the
``item`` being passed.
This method is invoked by pelican's core.
:param feed: A PodcastFeed instance.
:param item: An article (pelican's Article object).
"""
# Local copy of iTunes attributes to add to the feed.
article = DEFAULT_ITEM_ELEMENTS.copy()
article_values_map = [
[
"link",
lambda calee, item, article: "{0}/{1}".format(
calee.site_url, item.url),
],
[
"title",
lambda calee, item, article: Markup(item.title).striptags(),
], # NOQA E231
[
"itunes:summary",
lambda calee, item, article: item.description if hasattr(
item, "description") else Markup(item.summary).striptags(),
],
[
"description",
lambda calee, item, article: "<![CDATA[{}]]>".format(
Markup(item.summary)),
],
[
"pubDate",
lambda calee, item, article: rfc2822_date(
set_date_tzinfo(
item.modified
if hasattr(item, "modified") else item.date,
self.settings.get("TIMEZONE", None),
)),
],
["itunes:author", lambda calee, item, article: item.author.name],
[
"itunes:subtitle",
lambda calee, item, article: Markup(item.subtitle).striptags()
if hasattr(item, "subtitle") else None,
],
[
"itunes:image",
lambda calee, item, article: {
"href": "{0}{1}".format(self.site_url, item.image)
} if hasattr(item, "image") else None,
],
[
"guid",
lambda calee, item, article: item.guid
if hasattr(item, "guid") else article["link"],
],
]
def update_article(item, article, *args):
if len(args) == 2:
args = args + (None, )
_key, value, default = args
try:
val = value(self, item, article)
if val:
article[_key] = val
except Exception as e:
logger.warning("Exception %s", e)
for article_value_map in article_values_map:
update_article(item, article, *article_value_map)
# get file path to podcast attachment file.
def get_attachment_filepath(settings):
siteurl = self.settings.get("SITEURL", None)
content_path = self.settings.get("PATH", None)
if item.podcast.startswith(siteurl):
return f"{content_path}/{item.podcast[len(siteurl):]}"
def get_attachment_url(settings):
return item.podcast
enclosure = {"url": get_attachment_url(self.settings)}
if hasattr(item, "length"):
enclosure["length"] = item.length
if hasattr(item, "duration"):
article["itunes:duration"] = item.duration
filepath = get_attachment_filepath(self.settings)
if filepath and os.path.exists(filepath):
enclosure["length"] = str(os.path.getsize(filepath))
audiofile = mutagen.File(filepath)
(enclosure["type"], ) = set(
audiofile.mime) & set(SUPPORTED_MIME_TYPES)
article["itunes:duration"] = str(int(audiofile.info.length))
article["enclosure"] = enclosure
# Add the new article to the feed.
feed.add_item(**article)
