def edit(page = 1):
"""
进行互评
"""
log.info("edit")
user = request.get_cookie('user',secret="chermong")
user = db.user.find_one({'name':user})
schoolid,option = request.query.get('schoolid'),request.query.get('option')
db.assessment.update({'schoolid':user['schoolid'],"pro-others.schoolid":schoolid},{"$set":{"pro-others.$.option":option}})
pro_others = list(db.assessment.find_one({'schoolid':user['schoolid']},fields = ['pro-others'])['pro-others'])
options = list(db.options.find())#因为返回的是一个类似的list的cursor,但是它只能循环一次,所以将它转换为list
paginator = Paginator(pro_others,10,0)
pro_others = paginator.page(page)
page_range,num_pages = paginator.page_range,paginator.num_pages
show_firstpage = False if int(page) == 1 else True
show_lastpage = False if int(page) == num_pages else True
show_pages = 5
if num_pages <= show_pages:#当数量不足时
newpage_range = page_range
else:
newpage_range = list()
if int(page) + show_pages > num_pages:#用于显示后几位
for pagenum in range(num_pages - show_pages + 1,num_pages + 1):
newpage_range.append(pagenum)
else:
for pagenum in range(int(page),int(page)+show_pages):
newpage_range.append(pagenum)
return jinja2_template('edit-assessment.html',user = user,app = chermongapp,
options = options,pro_others = pro_others,show_firstpage=show_firstpage,
show_lastpage=show_lastpage,num_pages=num_pages,page_range=newpage_range)
def manage_user(page = 1):
"""
查看用户信息
"""
log.info("manage_user")
user = request.get_cookie('user',secret="chermong")
user = db.user.find_one({'name':user})
users = list(db.user.find())
paginator = Paginator(users,10,0)
try:
users = paginator.page(page)
except (EmptyPage, InvalidPage):
users = paginator.page(paginator.num_pages)
page_range,num_pages = paginator.page_range,paginator.num_pages
show_firstpage = False if int(page) == 1 else True
show_lastpage = False if int(page) == num_pages else True
show_pages = 5
if num_pages <= show_pages:#当数量不足时
newpage_range = page_range
else:
newpage_range = list()
if int(page) + show_pages > num_pages:#用于显示后几位
for pagenum in range(num_pages - show_pages + 1,num_pages + 1):
newpage_range.append(pagenum)
else:
for pagenum in range(int(page),int(page)+show_pages):
newpage_range.append(pagenum)
return jinja2_template('manage-user.html',user = user,app = chermongapp,
users = users,show_firstpage=show_firstpage,show_lastpage=show_lastpage,
num_pages=num_pages,page_range=newpage_range)
def get_results(self, request):
paginator = Paginator(self.query_set, self.list_per_page)
# Get the number of objects, with admin filters applied.
result_count = paginator.count
# Get the total number of objects, with no admin filters applied.
# Perform a slight optimization: Check to see whether any filters were
# given. If not, use paginator.hits to calculate the number of objects,
# because we've already done paginator.hits and the value is cached.
if not self.query_set._filtered:
full_result_count = result_count
else:
full_result_count = self.root_query_set.count()
can_show_all = result_count <= 1000
multi_page = result_count > self.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and can_show_all) or not multi_page:
result_list = self.query_set.fetch(1000)
else:
try:
result_list = paginator.page(self.page_num+1).object_list
except:
raise
self.result_count = result_count
self.full_result_count = full_result_count
self.result_list = result_list
self.can_show_all = can_show_all
self.multi_page = multi_page
self.paginator = paginator
def get_results(self, request):
paginator = Paginator(self.query_set, self.list_per_page)
# Get the number of objects, with admin filters applied.
result_count = paginator.count
# Get the total number of objects, with no admin filters applied.
# Perform a slight optimization: Check to see whether any filters were
# given. If not, use paginator.hits to calculate the number of objects,
# because we've already done paginator.hits and the value is cached.
if not self.query_set._filtered:
full_result_count = result_count
else:
full_result_count = self.root_query_set.count()
can_show_all = result_count <= 1000
multi_page = result_count > self.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and can_show_all) or not multi_page:
result_list = self.query_set.fetch(1000)
else:
try:
result_list = paginator.page(self.page_num + 1).object_list
except:
raise
self.result_count = result_count
self.full_result_count = full_result_count
self.result_list = result_list
self.can_show_all = can_show_all
self.multi_page = multi_page
self.paginator = paginator
def test_first_page_max_five_entries():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row, row])
page = paginator.get_first_page()
assert len(page.rows) == 5
def show_recipes(tag, start='a', page=0, refresh=False):
recipes = evernote_wrapper.get_recipes(tag, refresh)
logging.info('%s recipes', len(recipes))
paginator = Paginator(recipes, 'title', start, int(page), 6)
tagurl = '/tag/%s/' % tag
start += '/'
return render_template('recipes.html', recipes=paginator.page(), tagurl=tagurl, start=start, page=int(page))
def show_all(self):
item_index = None
while item_index is None:
channel = self.select_channel("List")
if channel is not None:
paginator = Paginator(channel.items)
while True:
# TODO: Replace with cli.py
for i, item in enumerate(paginator.get_current_page()):
print(
f" {i+paginator.current_min}) {item.title} ({item.enclosure.url}) Downloaded={item.downloaded}"
)
item_index = input(f"{channel.title}> ")
if item_index == "n":
self.paginator_next(paginator)
elif item_index == "p":
self.paginator_prev(paginator)
elif item_index == "q":
item_index = None
break
else:
print("Invalid Command!")
else:
break
def get(self, tag_name):
page = int(self.get_argument('page', 1))
sql = 'SELECT b.blog_id FROM blogs_tag AS a, blogs_blog_tag AS b WHERE a.name = %s AND a.id = b.tag_id'
query = self.db.query(sql, (tag_name,))
blog_ids = ','.join([str(item['blog_id']) for item in query])
count_sql = "SELECT count(*) FROM blogs_blog where id in (%s)" % blog_ids
query_sql = "SELECT * FROM blogs_blog where id in (%s) ORDER BY created DESC" % blog_ids
paginator = Paginator(db=self.db, count_sql=count_sql, query_sql=query_sql, per_page=PAGE_NUM)
try:
blogs = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
blogs = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
blogs = paginator.page(paginator.num_pages)
for item in blogs:
item['detail_url'] = '/blogs/%s/' % item.id
content = util.filter_html(item.content) if item.content else ""
item['brief'] = content[:100]
self.render("blogs/index.html",
blogs=blogs, selected_category=None, selected_tags=[tag_name],
**get_cat_tag(self))
def test_get_page_0(self):
""" """
paginator = Paginator(["a", "b", "c", "d"], 2)
page = paginator.get_page()
items = [item for item in page]
self.assertEqual(items[0], "a")
self.assertEqual(items[1], "b")
def test_jump_to_last_page_if_index_to_high():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row,
row, row, row, row])
page = paginator.jump_to_page(2)
assert len(page.rows) == 4
def test_next_page_contains_four_entries():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row,
row, row, row, row])
page = paginator.get_next_page()
assert len(page.rows) == 4
def test_jump_to_page():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row,
row, row, row, row])
page = paginator.jump_to_page(0)
assert len(page.rows) == 5
def test_include_page_number():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row])
page = paginator.get_first_page()
assert page.num == 1
assert page.total == 1
def show_tags(start='a', page=0, refresh=False):
tags = evernote_wrapper.get_tags(refresh)
paginator = Paginator(tags, 'name', start, int(page), 6)
start += '/'
return render_template('tags.html',
tags=paginator.page(),
tagurl='/',
start=start,
page=int(page))
def test_previous_page_stays_at_first_page():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row,
row, row, row, row])
paginator.get_previous_page()
page = paginator.get_previous_page()
assert len(page.rows) == 5
def test_last_page_contains_single_entry():
row = ["Paul", "12"]
last_row = ["Bob", "8"]
paginator = Paginator(header=[], rows=[row, row, row, row, row, last_row])
page = paginator.get_last_page()
assert len(page.rows) == 1
assert page.rows[0] == [6] + last_row
def test_index_for_last_page():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row,
row, row, row, row, row])
page = paginator.get_last_page()
assert len(page.rows) == 5
assert page.rows[0][0] == 6
def test_multiple_rows_have_index():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row])
page = paginator.get_first_page()
assert len(page.rows) == 2
for idx, row in enumerate(page.rows):
assert row[0] == idx + 1
def show_recipes(tag, start='a', page=0, refresh=False):
recipes = evernote_wrapper.get_recipes(tag, refresh)
logging.info('%s recipes', len(recipes))
paginator = Paginator(recipes, 'title', start, int(page), 6)
tagurl = '/tag/%s/' % tag
start += '/'
return render_template('recipes.html',
recipes=paginator.page(),
tagurl=tagurl,
start=start,
page=int(page))
def test_next_page_works_twice():
row = ["Paul", "12"]
paginator = Paginator(header=[], rows=[row, row, row, row, row,
row, row, row, row, row,
row, row, row, row, row,
row, row, row, row])
paginator.get_next_page()
page = paginator.get_next_page()
assert len(page.rows) == 5
def test_results_sorting(driver):
driver.maximize_window()
driver.get("https://shop.by/")
actions = ActionChains(driver)
laptops = get_catalog_item(driver, COMPUTERS_MENU_ITEM,
LAPTOP_SUBMENU_ITEM)
actions.move_to_element(laptops).click().perform()
actions.reset_actions()
if "noutbuki" not in driver.current_url:
raise Exception("Redirect to /%s page doesn't happened" % "noutbuki")
set_price_range(driver, min_price, max_price)
manufacture_filter = BaseFilterMenu(driver, MANUFACTURE_EXPAND_XPATH)
manufacture_filter.expand()
manufacture_filter.click_on_items(MANUFACTORY_LIST)
time.sleep(COMMON_TIMEOUT)
display_size_filter = BaseFilterMenu(driver, DISPLAY_SIZE_EXPAND_XPATH)
display_size_filter.expand()
display_size_filter.click_on_items(DISPLAY_SIZE_LIST)
time.sleep(COMMON_TIMEOUT)
filter_url = driver.current_url
apply_button = driver.find_element_by_class_name(SHOW_RES_BUTTON)
apply_button.click()
if driver.current_url == filter_url:
raise Exception("Redirect on result page is not happened.")
sorter = SortMenu(driver, SORTER_XPATH, SORTER_ITEMS)
sorter.select("price_asc")
results = Results(driver, RESULTS_XPATH)
assert results, "Got empty result list"
print("%s results on the page" % len(results))
flink = result_item_link(results[0])
sorter.select("price_desc")
time.sleep(3)
paginator = Paginator(driver, PAGINATOR_XPATH)
paginator.move_to_the_last()
time.sleep(COMMON_TIMEOUT)
llink = result_item_link(results[-1])
print(flink)
print(llink)
assert flink == llink, "First item in results sorted by price ascending is not equal " \
"to the latest item in results sorted by price descending"
def __init__(self, gqlQuery,page_number,per_page, count=None,orphans=0, allow_empty_first_page=True):
if count is not None:
#for the list large than 1000, we should pass the count value from the counter outside.
#as google appengine has the limitation of 1000 records from the GqlQuery.
self.count_ = count
else:
self.count_ = int(gqlQuery.count())
self.number = page_number
bottom = (self.number - 1) * per_page
self.object_list = gqlQuery.fetch(per_page,bottom)
Paginator.__init__(self, self.object_list, per_page, orphans, allow_empty_first_page)
def show_entries(view,pagin,page):
if view =='books':
entries_all = db_session.query(Book).all()
else :
entries_all = db_session.query(Author).all()
paginator = Paginator(entries_all,pagin)
try:
entries = paginator.page(page)
except PageNotAnInteger:
entries = paginator.page(1)
except EmptyPage:
entries = paginator.page(paginator.num_pages)
return render_template('show_entries.html', entries=entries, entries_per_page=pagin,view_mode=view, config=app.config)
def build_entry_list_pages(env, entries):
urls = []
entry_list_tpl = env.get_template("entry-list.html")
p = Paginator(ENTRIES_PER_PAGE, page_name="index")
for batch in p.paginate(entries):
entry_list_html = entry_list_tpl.render(entries=batch, paginator=p, page_name="index")
filename = "index.html"
if p.page_num > 1:
filename = f"index{p.page_num}.html"
path = join(INDEX_DIR, filename)
urls.append(build_sitemap_url(path, lastmod=env.globals['last_updated']))
write(path, entry_list_html)
return urls
async def cmd_id(self, message, args=[]):
pref = self.prefix_dict.get(str(message.guild.id), None)
if pref and args:
if len(args) > 1 and args[0] == 'search':
pokename = args[1]
results = self.get_id(pokename, True)
embeds = []
for i in range(0, len(results), 10):
embed = discord.Embed(title="Search Results", description="\u200B", color=15728640)
if results == "\u200B":
continue
else:
for result in results[i:i+10]:
embed.add_field(name=result[0], value=f"**ID**: {result[1]}\n**LEVEL**: {result[2]}", inline=False)
embeds.append(embed)
try:
base = await message.channel.send(content=None, embed=embeds[0])
pager = Paginator(message, base, embeds, self)
await pager.run()
except:
await message.channel.send(":cold_sweat: | No results found.")
else:
pokename = args[0]
results = self.get_id(pokename, True)
embed = discord.Embed(title=pokename.title(), description="\u200B", color=15728640)
if results == "\u200B":
await message.channel.send(":cold_sweat: | No results found.")
return
else:
for result in results:
embed.add_field(name="**ID**", value=f"{result[1]}", inline=False)
embed.add_field(name="**LEVEL**", value=f"{result[2]}", inline=False)
embed.add_field(name="-----", value="\u200B", inline=False)
await message.channel.send(content=None, embed=embed)
async def cmd_duplicates(self, message, args=[]):
pokemons = [pokemon.split(' -> ')[0] for pokemon in self.pokelist]
limit = 2
if args:
limit = int(args[0])
dups = {dup for dup in pokemons if pokemons.count(dup) >= limit}
if len(dups) == 0:
await message.channel.send(
"There is no pokemon with so many duplicates. Try a smaller number."
)
return
dups = list(dups)
dups = sorted(dups)
embeds = []
for i in range(0, len(dups), 10):
embed = discord.Embed(title="Duplicates",
description="\u200B",
color=15728640)
for dup in dups[i:i + 10]:
results = self.get_id(dup, True)
data = [
f"**ID**: {result[1]}\t**LEVEL**: {result[2]}"
for result in results
]
data.append(
'-------------------------------------------------')
embed.add_field(name=f"**{dup}**",
value='\n'.join(data),
inline=False)
embed.set_footer(text=f"{(i//10)+1}/{ceil(len(dups)/10)}")
embeds.append(embed)
base = await message.channel.send(content=None, embed=embeds[0])
pager = Paginator(message, base, embeds, self)
await pager.run()
def lookup(page = 1):
"""
显示查看页面
"""
log.info("lookup")
user = request.get_cookie('user',secret="chermong")
user = db.user.find_one({'name':user})
options = list(db.options.find())
origi_option = {i.get('option'):0 for i in options}
students = OrderedDict()#利用OrderedDict实现快速查找
for i in db.user.find({'role':'student'}):
user_info = {'name':i.get('name'),'schoolid':i.get('schoolid'),'sex':i.get('sex')}
user_info.update(origi_option)
students[i.get('schoolid')] = user_info
for i in db.assessment.find():
for j in i.get('pro-others'):
if j.get('option') in origi_option.keys():
students[j.get('schoolid')][j.get('option')]+=1
students = list(students.values())
#students = [{'name':u'郭猛','schoolid':'101110312','sex':u'男',u'优':14,u'良':12,u'一般':5}]
#注意：上面注释的写法，eg：u，数字的使用
paginator = Paginator(students,10,0)
students = paginator.page(page)
page_range,num_pages = paginator.page_range,paginator.num_pages
show_firstpage = False if int(page) == 1 else True
show_lastpage = False if int(page) == num_pages else True
show_pages = 5
if num_pages <= show_pages:#当数量不足时
newpage_range = page_range
else:
newpage_range = list()
if int(page) + show_pages > num_pages:#用于显示后几位
for pagenum in range(num_pages - show_pages + 1,num_pages + 1):
newpage_range.append(pagenum)
else:
for pagenum in range(int(page),int(page)+show_pages):
newpage_range.append(pagenum)
return jinja2_template('lookup.html',user = user,app = chermongapp,
options = options,students = students,show_firstpage=show_firstpage,
show_lastpage=show_lastpage,num_pages=num_pages,page_range=newpage_range)
def show_list(self):
plist = db.GqlQuery("SELECT * FROM Page ORDER BY url ASC")
for item in plist:
item.id = item.key().id()
# paginate
pg = Paginator(plist, PAGESIZE)
logging.info(pg)
pi = self.request.get("pg")
try:
pgdata = pg.page(pi)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
pgdata = pg.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
pgdata = pg.page(pg.num_pages)
logging.info(pgdata)
payload = { 'list': pgdata }
self.respond('page_list.html', payload)
async def cmd_legendary(self, message):
embeds = []
for i in range(0, len(self.legendaries), 5):
embed = discord.Embed(title="Legendaries", description="\u200B", color=15728640)
for legend in self.legendaries[i:i+5]:
embed.add_field(name=legend, value='\n'.join(self.get_id(legend)), inline=False)
embeds.append(embed)
base = await message.channel.send(content=None, embed=embeds[0])
pager = Paginator(message, base, embeds, self)
await pager.run()
def select_item_indexes(self, channel, purpose):
items = channel.items
paginator = Paginator(items)
# TODO: Can you do this without cont?
cont = True
while cont:
# TODO: Replace with cli.py
cont = False
for i, item in enumerate(paginator.get_current_page()):
print(
f" {i+paginator.current_min}) {item.title} ({item.enclosure.url}) Downloaded={item.downloaded}"
)
item_indexes = input(f"Which Items do you want {purpose}? ")
if item_indexes == "n":
self.paginator_next(paginator)
elif item_indexes == "p":
self.paginator_prev(paginator)
elif item_indexes == "q":
item_indexes = None
break
else:
try:
item_indexes = list(map(int, item_indexes.split(" ")))
except ValueError:
print("Invalid Input!")
cont = True
continue
for i in item_indexes:
if i > len(channel.items) or i < 0:
print(
f"Options must be between {0} and {len(channel.items)-1}"
)
cont = True
break
if cont:
continue
return item_indexes
class PaginatorTestCase(unittest.TestCase):
"""Unit tests for our custom paginator."""
def setUp(self):
self.paginator = Paginator(range(10), 5)
def test_small_page_number(self):
"""Numbers less than 1 should be rounded up to 1."""
page = self.paginator.page(-1)
self.assertEqual(1, page.number)
def test_large_page_number(self):
"""Numbers greater than the maximum n should be rounded down to n."""
page = self.paginator.page(3)
self.assertEqual(2, page.number)
def test_invalid_page_number(self):
"""Numbers that can't be converted to integers should default to 1."""
page = self.paginator.page("Hello!")
self.assertEqual(1, page.number)
def test_paginator():
items = range(1, 491)
p = Paginator(items, page=1, per_page=20)
assert p.page == 1
assert not p.has_prev
assert p.has_next
assert p.total_items == 490
assert p.total_pages == 25
assert p.next_page_number == 2
assert list(p.pages) == [1, 2, 3, 4, None, 24, 25]
assert p.pages_range == (0, 19)
p.page = 10
assert p.page == 10
assert p.has_prev
assert list(p.pages) == [1, 2, None, 7, 8, 9, 10, 11, 12, 13, None, 24, 25]
assert list(p) == list(range(181, 201))
assert Paginator(range(5))
def get(self):
page = int(self.get_argument('page', 1))
count_sql = "SELECT count(*) FROM blogs_blog"
query_sql = "SELECT * FROM blogs_blog ORDER BY created DESC"
paginator = Paginator(db=self.db, count_sql=count_sql, query_sql=query_sql, per_page=PAGE_NUM)
try:
blogs = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
blogs = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
blogs = paginator.page(paginator.num_pages)
for item in blogs:
item['detail_url'] = '/blogs/%s/' % item.id
content = util.filter_html(item.content) if item.content else ""
item['brief'] = content[:100]
self.render("blogs/index.html",
blogs=blogs, selected_category=None, selected_tags=[],
**get_cat_tag(self))
def select_channel(self, purpose):
channels = list(self.manager.channels.values())
paginator = Paginator(channels)
if len(channels) == 0:
print("No Podcasts Available Yet!")
return
while True:
for i, channel in enumerate(paginator.get_current_page()):
print(f"{i+paginator.current_min}) {channel.title}")
# TODO: Replace with cli.py
channel_index = input(
f"Which Channel do you want to {purpose} from? ")
if channel_index == "n":
self.paginator_next(paginator)
elif channel_index == "p":
self.paginator_prev(paginator)
elif channel_index == "q":
channel_index = None
break
else:
try:
channel_index = int(channel_index)
except ValueError:
print("Invalid Input!")
continue
if channel_index > len(
self.manager.channels.keys()) or channel_index < 0:
print(
f"Option must be between {0} and {len(self.manager.channels.keys())}"
)
continue
return self.manager.channels[self.manager.title_to_url[
channels[channel_index].title]]
def paginate(iter, **kwargs):
"""
A wrapper around the Paginator that takes config data
:param iter: Query object or any iterables
:param kwargs:
- page: current page
- per_page: max number of items per page
- total: Max number of items. If not provided, it will use the query to count
- padding: Number of elements of the next page to show
- callback: a function to callback on each item being iterated.
- static_query: bool - When True it will return the query as is, without slicing/limit. Usally when using the paginator to just create the pagination.
:return: Paginator
"""
kwargs.setdefault("page", int(request.args.get('page', 1)))
kwargs.setdefault("per_page", int(config("PAGINATION_PER_PAGE", 1)))
kwargs.setdefault("padding", int(config("PAGINATION_PADDING", 0)))
return Paginator(iter, **kwargs)
def terms(request):
c = get_context(request,
css_class='body-glossary',
title=_(u'¿Qué significa?'))
c['query'] = request.GET.get('q', '')
c['query_string'] = "q=%s&" % (c['query'])
c['page'] = request.GET.get('page', 1)
results = Paginator(list(
GlossaryTerm.objects.search(c['query'], c['LANGUAGE_CODE'])),
PAGE_LENGTH,
body=6,
padding=2)
c['terms'] = results.page(c['page'])
return render_response('terms/index.html', c)
class Commandline:
def __init__(self, file_name):
header, rows = read(file_name)
self.paginator = Paginator(header=header, rows=rows)
def start(self):
return self.paginator.get_first_page()
def execute(self, param):
command = param.lower()
if command in commands:
if command == 'j':
return self._jump_to_page()
else:
return commands[command](self.paginator)
raise AttributeError("unknown command entered")
def _jump_to_page(self):
print("Input page index:")
user_input = str(input())
return commands['j'](self.paginator, int(user_input) - 1)
def __init__(self, file_name):
header, rows = read(file_name)
self.paginator = Paginator(header=header, rows=rows)
def __init__(self, gqlQuery,page_number,per_page, orphans=0, allow_empty_first_page=True):
self.count_ = int(gqlQuery.count()) ##todo:google GqlQuery has 1000 records limit.
self.number = page_number
bottom = (self.number - 1) * per_page
self.object_list = gqlQuery.fetch(per_page,bottom)
Paginator.__init__(self, self.object_list, per_page, orphans, allow_empty_first_page)
def test_next_page(self):
""" """
paginator = Paginator(["a", "b", "c", "d"], 2)
self.assertEqual(paginator.next_page(), 1)
self.assertEqual(paginator.next_page(1), None)
self.assertEqual(paginator.next_page(2), None)
def paginate(objects_list,request):
paginator = Paginator(objects_list,5)
page = request.GET.get('page')
contacts = paginator.page(page)
return contacts
def paginate(objects_list, request):
paginator = Paginator(objects_list, 5)
page = request.GET.get('page')
contacts = paginator.page(page)
return contacts
def test_previous_page(self):
""" """
paginator = Paginator(["a", "b", "c", "d"], 2)
self.assertEqual(paginator.previous_page(), None)
self.assertEqual(paginator.previous_page(1), 0)
def test_is_empty(self):
""" """
paginator = Paginator([], 2)
self.assertTrue(paginator.is_empty())
from paginator import Paginator
from helpers import to_html, br_month_filter
app = Flask(__name__)
app.config.from_object('beerapp.settings')
db = SQLAlchemy(app)
gravatar = Gravatar(app,
size=120,
rating='x',
default='retro',
force_default=False,
force_lower=False)
paginator = Paginator(app)
from members import Members
members = Members(app)
app.jinja_env.filters['br_month'] = br_month_filter
from posts import BlogPost
from feed_generator import FeedGenerator
def TAGS():
_TAGS = []
members_str = open(app.config['MEMBERS_FILE']).read()
def paginate(self, **kwargs):
"""Paginate this results.
Returns an :class:`Paginator` object.
"""
return Paginator(self, **kwargs)
def test_is_not_empty(self):
""" """
paginator = Paginator(["a", "b", "c", "d"], 2)
self.assertTrue(paginator.is_not_empty())
def __init__(self, gqlQuery,page_number,per_page, orphans=0, allow_empty_first_page=True):
self.gqlQuery = gqlQuery
self.number = page_number
bottom = (self.number - 1) * per_page
self.object_list = gqlQuery.fetch(per_page,bottom)
Paginator.__init__(self, self.object_list, per_page, orphans, allow_empty_first_page)
async def shop(self, ctx, *args):
if len(args) == 0:
pages = []
# Getting the items that are in the shop
shop_items = []
shop_items = self.stock
shop_items = sorted(shop_items, key=lambda x: x.name)
# Putting descriptions together
n = 5
strings = []
string = ''
page_items = []
current_page_items = []
for i, item in enumerate(shop_items):
current_page_items.append(item)
string = string + item.get_shop_string()
if i % n == n - 1:
strings.append(string)
string = ""
page_items.append(current_page_items)
current_page_items = []
if string:
strings.append(string)
page_items.append(current_page_items)
for s in strings:
if pages == []:
h, m, _ = get_time_to_shop_refresh()
reset_message = f"*The store will change its stock in {h:02}h {m:02}m*"
pages.append(
discord.Embed(
title='Dyson Centre Store',
description=
"Yo, welcome kiddos! Come spend your {} **Standard Credits**!\n`dad buy <item> <amount>` to buy items.\n`dad shop <item>` for more info on an item.\n\n"
.format(SC_EMOJI) + reset_message,
colour=discord.Color.gold()))
else:
pages.append(discord.Embed(colour=discord.Color.gold()))
pages[-1].add_field(name='Items', value=s, inline=False)
menu = Paginator(self.bot,
ctx,
pages,
page_items,
self,
timeout=60)
await menu.run()
else:
item = " ".join(args)
i = items.get_by_name(item)
if i is not None:
if i.can_be_in_shop(): # If has shop_item in data
desc = '**COST: {} {}**'.format(SC_EMOJI, i.cost)
if not i in self.stock:
desc = desc + "\n*Currently not in stock*"
else:
desc = "*Can't be bought in the shop*"
if i.has_value(): # If has cost in its data
desc = "**Value: {} {}**\n*Can't be bought in the shop*".format(
SC_EMOJI, i.cost)
item_disp = discord.Embed(title=i.emoji + " " + i.name,
description=desc,
colour=discord.Colour.gold())
item_disp.add_field(name='Description',
value=i.description,
inline=False)
if i.is_booster():
text = "_Each gives a_ {:.1f}% _bonus to_ **{}**_, up to a maximum of_ {}%.".format(
i.boost_bonus * 100, i.boost_category.title(),
i.boost_max_bonus * 100)
item_disp.add_field(name='Booster',
value=text,
inline=False)
await ctx.send('', embed=item_disp)
else:
await ctx.send(
"That item doesn't exist... have you been smoking the devil's lettuce again son?!"
)
def test_get_all(self):
""" """
paginator = Paginator(["a", "b", "c", "d"])
self.assertEquals(paginator.get_all(), ["a", "b", "c", "d"])
def show_tags(start='a', page=0, refresh=False):
tags = evernote_wrapper.get_tags(refresh)
paginator = Paginator(tags, 'name', start, int(page), 6)
start += '/'
return render_template('tags.html', tags=paginator.page(), tagurl='/', start=start, page=int(page))
def setUp(self):
self.paginator = Paginator(range(10), 5)
from paginator import Paginator
from pysql import PySQL
from local_settings import DATABASE
db = PySQL(DATABASE.get('USER'),DATABASE.get('PASSWORD'),DATABASE.get('NAME'),DATABASE.get('HOST'),DATABASE.get('PORT'))
p = Paginator(max_page_size=100,url='http://localhost:8000/users?dir=prev&last_seen=48&page=3&page_size=20',page_number=2,page_size=4,
last_seen=49,direction='prev')
print (p.get_order_by())
print (p.get_filter_data(),p.page_size)
filter_data={
"state":{"$in":['closed','open']},
"operator":{"$sw":"s"},
#"message":{"$contains":"with"},
#"$or":[{"event_id":3},{"event_id":5}]
#"$xor":[{"event_id":3},{"event_id":{"$gte":5}},{"event_id":{"$null":False}}]
}
from flask import Flask, g, render_template, request
from flaskext.gravatar import Gravatar
from flaskext.sqlalchemy import SQLAlchemy
from paginator import Paginator
from helpers import to_html, br_month_filter
app = Flask(__name__)
app.config.from_object('beerapp.settings')
db = SQLAlchemy(app)
gravatar = Gravatar(app,size=75,rating='x',default='retro',force_default=False,force_lower=False)
paginator = Paginator(app)
from members import Members
members = Members(app)
app.jinja_env.filters['br_month'] = br_month_filter
from posts import *
paginator.register('posts', BlogPost.query.count)
from feed_generator import FeedGenerator
@app.route('/')
@to_html('index.html')
def index():
