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_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
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()
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)
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 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_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_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_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 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
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 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 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 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
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)
def do_search():
# extract query string and query settings
query = request.args['query']
# pull out paginate option
paginate = bool(request.args.get("paginate", True))
# pull out current page option
page = int(request.args.get("page", 1))
res = {"query": query}
# search for nodes
try:
nodes = searcher.search(query)
except Exception as err:
nodes = []
print(err)
if nodes == 'vague':
res["message"] = "vague"
nodes = []
exported_nodes = [export_node_contents(n) for n in nodes]
if paginate:
paginator = Paginator(exported_nodes, page)
res["results"] = paginator.export_page_items()
res["pagination"] = {
"hits": paginator.hits(),
"limit": paginator.page_limit(),
"page": paginator.cur_page(),
"totalPages": paginator.num_pages(),
"hasNextPage": paginator.has_next_page(),
"nextPage": paginator.next_page(),
"hasPrevPage": paginator.has_prev_page(),
"prevPage": paginator.prev_page()
}
else:
res["results"] = exported_nodes
# return json result
return res
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
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]]
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}}]
}
def __init__(self, file_name):
header, rows = read(file_name)
self.paginator = Paginator(header=header, rows=rows)
def paginate(objects_list, request):
paginator = Paginator(objects_list, 5)
page = request.GET.get('page')
contacts = paginator.page(page)
return contacts
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)
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?!"
)
