def get_results(project_name, page=1): res = [] pagination = paginate(Mongo.get()['result_' + project_name].find().sort('_id', -1), page, 20) if pagination: for doc in pagination.result(): del doc['_id'] res.append(doc) return json.dumps({'result': res, 'render_json': pagination.render_json(10)})
def get_results(project_name, page=1): res = [] pagination = paginate(Mongo.get()["result_" + project_name].find().sort("_id", -1), page, 20) if pagination: for doc in pagination.result(): del doc["_id"] res.append(doc) return json.dumps({"result": res, "render_json": pagination.render_json(10)})
def get_results(project_name, page=1): res = [] pagination = paginate( Mongo.get()['result_' + project_name].find().sort('_id', -1), page, 20) if pagination: for doc in pagination.result(): del doc['_id'] res.append(doc) return json.dumps({ 'result': res, 'render_json': pagination.render_json(10) })
def search(): artist = request.args.get('artist').title() # get page from query params or default to first page page = request.args.get('page') if request.args.get('page') else 1 # search by artist name split_words = artist.split() last_word = split_words[1:] prefix = ' '.join(split_words[:-1]) suggestions = list(root.query(artist)) full_suggestions = [] indx = 0 for suggestion in suggestions: full_suggestions.append({ "id": indx + 1, "artistName": '{}'.format(suggestion[0]).strip(), "rank": suggestion[1], }) indx = indx + 1 del indx sorted_suggestions = sorted(full_suggestions, key=lambda k: k['rank'], reverse=True) # get pager object for specified page pager = json.loads(paginate(len(sorted_suggestions), int(page))) # get page of items from suggestions pageOfItems = sorted_suggestions[pager['startIndex']:pager['endIndex'] + 1] resp = jsonify({'pager': pager, 'pageOfItems': pageOfItems}) resp.headers.add("Access-Control-Allow-Headers", "*") resp.status_code = 200 return resp
def api_test(): try: client = MongoClient('localhost', 27017) res = client['pyfetch']['result_cnbeta'].find().limit(10) # print GlobalHelper.get('salve_record') # time.sleep(10) pagination = paginate(Mongo.get()['result_cnbeta'].find(), 1, 30) if pagination: for row in pagination.current_page(): print row # print pagination.next() # print pagination.prev() except: print traceback.format_exc() return jsonify({'fd': 1})
def main(): parser = argparse.ArgumentParser() parser.add_argument('file_path', help='path to the CSV input file') parser.add_argument('--sort-by', help="name of column to sort by", required=True) parser.add_argument('--page-size', type=int, help="number of records per page (minimum 1)", required=True) parser.add_argument('--page-num', type=int, help="page number to show (minimum 1)", required=True) args = parser.parse_args() with open(args.file_path) as f: file_text = f.read() output_text = paginate(file_text, sort_by=args.sort_by, page_size=args.page_size, page_num=args.page_num) print(output_text)
def search(): search_form = Search(request.args) voters = Voter.search(search_form.query.data, search_form.type.data) context = {"form": search_form} context.update(paginate(voters)) return render_template("voter_list.search.html", **context)
def voters_by_precinct(precinct): voters = Voter.select().where(registeredprecinct=precinct) context = {"precinct": precinct} context.update(paginate(voters)) return render_template("voter_list.precinct.html", **context)
def _get_tree_lines(self): tree = self._tree depth = 0 max_depth = depth is_last_child = True dfs_stack = [(tree.get_node(self._root), depth, is_last_child)] lines = [] siblings_of_selected = None children_of_root = self._children(self._tree, self._tree.root) children_of_root.sort(self._compare_nodes) children_of_root.reverse() while dfs_stack: node, depth, is_last_child = dfs_stack.pop() max_depth = max(depth, max_depth) lines.append((node, depth, is_last_child)) if depth < self._max_allowed_depth: children = self._children(tree, node.identifier) if node.identifier == self._node_shown_as_selected.bpointer: siblings_of_selected = children if children: children.sort(self._compare_nodes) dfs_stack.append((children[0], depth + 1, True)) dfs_stack.extend([(child, depth + 1, False) for child in children[1:]]) does_parent_in_height_n_has_more_nodes = [False] * (max_depth + 1) if siblings_of_selected is None: siblings_of_selected = self._get_siblings_of_node( tree, self._node_shown_as_selected) siblings_of_selected.sort(self._compare_nodes) siblings_of_selected.reverse() index_of_selected = siblings_of_selected.index( self._node_shown_as_selected) nr_items_to_remove_at_beginning, nr_items_to_remove_at_end = ( pagination.paginate(len(siblings_of_selected), index_of_selected, self._max_nr_lines)) index_in_siblings_of_selected = 0 for node, depth, is_last_child in lines: if not self._including_root and node.identifier == self._tree.root: continue if node.identifier == self._node_shown_as_selected.identifier: color = "blue" if node.identifier in self._picked_nodes else "green" elif node.identifier in self._picked_nodes: color = "red" else: color = None pre_line = ">" if node.identifier == self._node_shown_as_selected.identifier else " " pre_line += " " pre_line += "X" if node.identifier in self._picked_nodes else " " if hasattr(node, 'original_matching' ) and node.original_matching and self._search_pattern: if color is None: color = "yellow" pre_line += "~" else: pre_line += " " does_parent_in_height_n_has_more_nodes[depth] = not is_last_child lower_depth_marks = "" current_depth_marks = "" if node.identifier != self._root: for lower_depth in xrange(1, depth): if does_parent_in_height_n_has_more_nodes[lower_depth]: lower_depth_marks += "\xe2\x94\x82 " else: lower_depth_marks += " " if is_last_child: current_depth_marks += '\xe2\x94\x94' else: if not self._including_root and node == children_of_root[0]: current_depth_marks += '\xe2\x94\x8c' else: current_depth_marks += '\xe2\x94\x9c' current_depth_marks += '\xe2\x94\x80' * 2 current_depth_marks += " " prefix = pre_line + lower_depth_marks + current_depth_marks if isinstance(node.tag, str): tag_lines = [[[node_line, color, False]] for node_line in node.tag.splitlines()] else: tag_lines = list(node.tag) lines = list() lines.append((prefix, color, False)) lines.extend(tag_lines[0]) lines.append(('\n', None, False)) non_first_lines_addition = ' ' * len(pre_line) + lower_depth_marks if is_last_child: non_first_lines_addition += ' ' else: non_first_lines_addition += '\xe2\x94\x82' + ' ' for tag_line in tag_lines[1:]: lines.append((non_first_lines_addition, None, False)) lines.extend(tag_line) lines.append(('\n', None, False)) if node.bpointer == self._node_shown_as_selected.bpointer: index_in_siblings_of_selected += 1 if nr_items_to_remove_at_beginning and index_in_siblings_of_selected == 1: tag = prefix + "... (%d more)\n" % ( nr_items_to_remove_at_beginning) yield tag, None, False continue elif index_in_siblings_of_selected <= nr_items_to_remove_at_beginning: continue elif (nr_items_to_remove_at_end and index_in_siblings_of_selected == len(siblings_of_selected)): tag = prefix + "... (%d more)\n" % ( nr_items_to_remove_at_end) yield tag, None, False continue elif index_in_siblings_of_selected > len( siblings_of_selected) - nr_items_to_remove_at_end: continue if self._children( tree, node.identifier) and depth == self._max_allowed_depth: if len(tag_lines) > 1: addition = '\n' + non_first_lines_addition else: addition = ' ' lines[-1] = ( lines[-1][0][:-1] + addition + "(...)" + "\n", lines[-1][1], lines[-1][2], ) for line, color, is_bold in lines: yield line, color, is_bold
def process_list(self, data): """Processes whole errata_list/errata_schema and returns info.""" modified_since = data.get("modified_since", "") errata_to_process = data.get("errata_list", None) errata_to_search = data.get("errata_search", None) page = data.get("page", None) page_size = data.get("page_size", None) response = {"errata_list": {}} if modified_since: response["modified_since"] = modified_since if not errata_to_process and errata_to_search: errata_to_process = self._fill_errata(errata_to_search) elif not errata_to_process and not errata_to_search: return response result = {} errata_page_to_process, pagination_response = paginate( errata_to_process, page, page_size) db_connection = self.db_pool.get_connection() with db_connection.get_cursor() as cursor: cursor.execute( """select distinct e.updated, es.name as severity, e.issued, e.description, e.solution, e.summary, e.name as url, e.synopsis, et.name as type from errata e left join errata_severity es on e.severity_id = es.id left join errata_type et on e.errata_type_id = et.id where e.name in %s """, [tuple(errata_page_to_process, )]) for i, errata in enumerate(cursor): result[errata_page_to_process[i]] = {} result[errata_page_to_process[i]] = { "updated": errata[ERRATA_UPDATED], "severity": errata[ERRATA_SEVERITY], "reference_list": self._build_references(errata_page_to_process), "issued": errata[ERRATA_ISSUED], "description": errata[ERRATA_DESCRIPTION], "solution": errata[ERRATA_SOLUTION], "summary": errata[ERRATA_SUMMARY], "url": "https://access.redhat.com/errata/%s" % str(errata[ERRATA_URL]), "synopsis": errata[ERRATA_SYNOPSIS], "cve_list": self._build_cve_list(errata_page_to_process), "bugzilla_list": self._build_references(errata_page_to_process, bugzilla=True), "package_list": self._build_package_list(errata_page_to_process), "source_package_list": self._build_package_list(errata_page_to_process, source=True), "type": errata[ERRATA_TYPE] } response["errata_list"].update(result) response.update(pagination_response) self.db_pool.return_connection(db_connection) return response