def get_images(self, page=1, category='all', order_by='created_at', limit=None): if limit: images = orm.select(rv for rv in m.Image if rv.user_id == self.id).order_by(lambda rv: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5)) return images[:limit] if category == 'all': images = orm.select(rv for rv in m.Image if rv.user_id == self.id) else: images = orm.select(rv for rv in m.Image if rv.user_id == self.id and rv.role == category) if order_by == 'created_at': images = images.order_by(lambda rv: orm.desc(rv.created_at)) elif order_by == 'up_count': images = images.order_by(lambda rv: orm.desc(rv.up_count)) elif order_by == 'thank_count': images = images.order_by(lambda rv: orm.desc(rv.thank_count)) elif order_by == 'smart': images = images.order_by(lambda rv: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5 + rv.created_at / 4)) if page: return images[(page - 1) * config.paged: page * config.paged] else: return images
def add(self, key, value): # value must be a list elem = select( e for e in self.Store if e.key == key).order_by(lambda o: desc(o.create_at)).first() if elem: value_db = copy(elem.value) if isinstance(value_db, list): if isinstance(value, str): vs = [value] if value not in value_db else [] else: vs = [v for v in value if v not in value_db] value_db.extend(vs) elem.value = value_db elem.update_at = datetime.utcnow() commit() if key not in self.ids: self.ids.add(key) else: if isinstance(value, str): self.Store(key=key, value=[value]) else: self.Store(key=key, value=value) if key not in self.ids: self.ids.add(key) elem = select( e for e in self.Store if e.key == key).order_by(lambda o: desc(o.create_at)).first() return { 'key': elem.key, 'value': elem.value, 'create_at': elem.create_at.strftime("%Y-%m-%d %H:%M:%S"), 'update_at': elem.update_at.strftime("%Y-%m-%d %H:%M:%S"), }
def album_list(): ltype = request.values['type'] size, offset = map(request.values.get, [ 'size', 'offset' ]) size = int(size) if size else 10 offset = int(offset) if offset else 0 query = select(t.folder for t in Track) if ltype == 'random': return request.formatter('albumList', dict( album = [ a.as_subsonic_child(request.user) for a in query.without_distinct().random(size) ] )) elif ltype == 'newest': query = query.order_by(desc(Folder.created)) elif ltype == 'highest': query = query.order_by(lambda f: desc(avg(f.ratings.rating))) elif ltype == 'frequent': query = query.order_by(lambda f: desc(avg(f.tracks.play_count))) elif ltype == 'recent': query = select(t.folder for t in Track if max(t.folder.tracks.last_play) is not None).order_by(lambda f: desc(max(f.tracks.last_play))) elif ltype == 'starred': query = select(s.starred for s in StarredFolder if s.user.id == request.user.id and count(s.starred.tracks) > 0) elif ltype == 'alphabeticalByName': query = query.order_by(Folder.name) elif ltype == 'alphabeticalByArtist': query = query.order_by(lambda f: f.parent.name + f.name) else: raise GenericError('Unknown search type') return request.formatter('albumList', dict( album = [ f.as_subsonic_child(request.user) for f in query.limit(size, offset) ] ))
def get_entries_query(cls, sort_by=None, sort_asc=True, query_filter=None): """ Get some metadata entries. Optionally sort the results by a specific field, or filter the channels based on a keyword/whether you are subscribed to it. :return: A tuple. The first entry is a list of ChannelMetadata entries. The second entry indicates the total number of results, regardless the passed first/last parameter. """ # Warning! For Pony magic to work, iteration variable name (e.g. 'g') should be the same everywhere! # Filter the results on a keyword or some keywords pony_query = cls.search_keyword( query_filter, lim=1000) if query_filter else select( g for g in cls) # Sort the query sort_expression = None if sort_by: if sort_by == "HEALTH": pony_query = pony_query.sort_by("(g.health.seeders, g.health.leechers)") if sort_asc else \ pony_query.sort_by("(desc(g.health.seeders), desc(g.health.leechers))") else: sort_expression = "g." + sort_by sort_expression = sort_expression if sort_asc else desc( sort_expression) pony_query = pony_query.sort_by(sort_expression) # Workaround to always show legacy entries last pony_query = pony_query.order_by(lambda g: (desc(g.status != LEGACY_ENTRY), sort_expression)) \ if sort_expression else pony_query.order_by(lambda g: desc(g.status != LEGACY_ENTRY)) return pony_query
def torrents_to_check(self): """ Two categories of torrents are selected (popular & old). From the pool of selected torrents, a certain number of them are submitted for health check. The torrents that are within the freshness window are excluded from the selection considering the health information is still fresh. 1. Popular torrents (50%) The indicator for popularity here is considered as the seeder count with direct proportionality assuming more seeders -> more popular. There could be other indicators to be introduced later. 2. Old torrents (50%) By old torrents, we refer to those checked quite farther in the past, sorted by the last_check value. """ last_fresh_time = time.time() - HEALTH_FRESHNESS_SECONDS popular_torrents = list( self.tribler_session.mds.TorrentState.select( lambda g: g.last_check < last_fresh_time).order_by( lambda g: (desc(g.seeders), g.last_check)).limit( TORRENT_SELECTION_POOL_SIZE)) old_torrents = list( self.tribler_session.mds.TorrentState.select( lambda g: g.last_check < last_fresh_time).order_by( lambda g: (g.last_check, desc(g.seeders))).limit( TORRENT_SELECTION_POOL_SIZE)) selected_torrents = popular_torrents + old_torrents selected_torrents = random.sample( selected_torrents, min(TORRENT_SELECTION_POOL_SIZE, len(selected_torrents))) return selected_torrents
def get_images(self, page=1, category='all', order_by='created_at', limit=None, desc=True): if category == 'all': images = m.Image.select(lambda rv: rv.album_id == self.id) else: if category == 'hot': images = m.Image.select(lambda rv: rv.album_id == self.id) limit = 10 order_by = 'smart' elif category == 'author': images = orm.select(rv for rv in m.Image if rv.topic_id == self.id and rv.user_id == self.user_id) else: images = orm.select(rv for rv in m.Image if rv.album_id == self.id and rv.role == category) if order_by == 'smart': images = images.order_by(lambda rv: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5)) else: if desc: images = images.order_by(lambda rv: orm.desc(rv.created_at)) else: images = images.order_by(lambda rv: rv.created_at) if limit: return images[:limit] elif page: return images[(page - 1) * config.paged: page * config.paged] else: return images
def remove(self, key, value): # value must be a list elem = select( e for e in self.Store if e.key == key).order_by(lambda o: desc(o.create_at)).first() if elem: value_db = copy(elem.value) if isinstance(value_db, list): if isinstance(value, str): vs = [value] if value in value_db else [] else: vs = [v for v in value if v in value_db] for vv in vs: value_db.remove(vv) elem.value = value_db elem.update_at = datetime.utcnow() commit() elem = select( e for e in self.Store if e.key == key).order_by(lambda o: desc(o.create_at)).first() return { 'key': elem.key, 'value': elem.value, 'create_at': elem.create_at.strftime("%Y-%m-%d %H:%M:%S"), 'update_at': elem.update_at.strftime("%Y-%m-%d %H:%M:%S"), }
def _last(self, **spec): """ Get the latest entry in this category, optionally including subcategories """ for record in self._entries(spec).order_by( orm.desc(model.Entry.local_date), orm.desc(model.Entry.id))[:1]: return entry.Entry(record) return None
def get_data(): node = request.args.getlist('node', None) limit = request.args.get('limit', 100) assert isinstance(limit, int) or str.isnumeric( limit) # TODO: specify error message, on error # like int("abc") limit = int(limit) if node: for i in node: assert str.isnumeric(i) # TODO: specify error message # end for node_values = orm.select(m for m in DBInitMessage if m.node in list(node)).order_by( orm.desc(DBInitMessage.date)).limit(limit) else: node_values = orm.select(m for m in DBInitMessage).order_by( orm.desc(DBInitMessage.date)).limit(limit) if not node_values: return jsonify({}, allow_all_origin=True) # end if data = {} for msg in node_values: assert isinstance(msg, DBInitMessage) assert isinstance(msg.date, datetime) if str(msg.node) not in data: data[str(msg.node)] = dict() # end if data[str(msg.node)][msg.date.timestamp()] = msg.value # end for return jsonify(data, allow_all_origin=True)
def album_list(): ltype = request.values["type"] size, offset = map(request.values.get, ("size", "offset")) size = int(size) if size else 10 offset = int(offset) if offset else 0 query = select(t.folder for t in Track) if ltype == "random": return request.formatter( "albumList", { "album": [ a.as_subsonic_child(request.user) for a in distinct(query.random(size)) ] }, ) elif ltype == "newest": query = query.sort_by(desc(Folder.created)).distinct() elif ltype == "highest": query = query.sort_by(lambda f: desc(avg(f.ratings.rating))) elif ltype == "frequent": query = query.sort_by(lambda f: desc(avg(f.tracks.play_count))) elif ltype == "recent": query = select(t.folder for t in Track if max(t.folder.tracks.last_play) is not None).sort_by( lambda f: desc(max(f.tracks.last_play))) elif ltype == "starred": query = select( s.starred for s in StarredFolder if s.user.id == request.user.id and count(s.starred.tracks) > 0) elif ltype == "alphabeticalByName": query = query.sort_by(Folder.name).distinct() elif ltype == "alphabeticalByArtist": query = query.sort_by(lambda f: f.parent.name + f.name) elif ltype == "byYear": startyear = int(request.values["fromYear"]) endyear = int(request.values["toYear"]) query = query.where(lambda t: between(t.year, min(startyear, endyear), max(startyear, endyear))) if endyear < startyear: query = query.sort_by(lambda f: desc(min(f.tracks.year))) else: query = query.sort_by(lambda f: min(f.tracks.year)) elif ltype == "byGenre": genre = request.values["genre"] query = query.where(lambda t: t.genre == genre) else: raise GenericError("Unknown search type") return request.formatter( "albumList", { "album": [ f.as_subsonic_child(request.user) for f in query.limit(size, offset) ] }, )
def get_users(page=1, category='all', limit=None): if category == 'all': users = orm.select(rv for rv in User).order_by(lambda: orm.desc(rv.created_at)) elif category == 'hot': users = mc.get('hot_users') if not users: if not limit: limit = 8 users = orm.select(rv for rv in User).order_by(lambda: orm.desc(rv.thank_count * 4 + rv.up_count * 3 + rv.topic_count * 2 + rv.reply_count))[:limit] mc.set('hot_users', list(users), 60 * 60 * 12) elif category == 'new': users = orm.select(rv for rv in User).order_by(lambda: orm.desc(rv.created_at)) else: return [] if limit: return users[:limit] if page: return users[(page - 1) * config.user_paged: page * config.user_paged] else: return users
def get_entries_query(cls, sort_by=None, sort_asc=True, query_filter=None): """ Get some metadata entries. Optionally sort the results by a specific field, or filter the channels based on a keyword/whether you are subscribed to it. :return: A tuple. The first entry is a list of ChannelMetadata entries. The second entry indicates the total number of results, regardless the passed first/last parameter. """ # Warning! For Pony magic to work, iteration variable name (e.g. 'g') should be the same everywhere! # Filter the results on a keyword or some keywords pony_query = cls.search_keyword(query_filter, lim=1000) if query_filter else select(g for g in cls) # Sort the query sort_expression = None if sort_by: if sort_by == "HEALTH": pony_query = pony_query.sort_by("(g.health.seeders, g.health.leechers)") if sort_asc else \ pony_query.sort_by("(desc(g.health.seeders), desc(g.health.leechers))") else: sort_expression = "g." + sort_by sort_expression = sort_expression if sort_asc else desc(sort_expression) pony_query = pony_query.sort_by(sort_expression) # Workaround to always show legacy entries last pony_query = pony_query.order_by(lambda g: (desc(g.status != LEGACY_ENTRY), sort_expression)) \ if sort_expression else pony_query.order_by(lambda g: desc(g.status != LEGACY_ENTRY)) return pony_query
def read(page=None, order="date"): post_query = Post.select() post_count = count(post_query) if order == "date": post_query = post_query.order_by(desc(Post.date_created)) if "thumbs" in order: up = "up" in order post_query = post_query.order_by( lambda p: desc(count(t for t in p.thumbs if t.up == up))) if page: posts = list(post_query.page(page)) else: posts = list(post_query) posts_json = { "count": post_count, "posts": [{ "id": p.id, "content": p.content, "up": len([t for t in p.thumbs if t.up]), "down": len([t for t in p.thumbs if not t.up]), "date_created": p.date_created.timestamp() } for p in posts] } return posts_json
def get_albums(self, page=1, category='all', order_by='created_at', limit=None): if limit: albums = orm.select(rv for rv in collipa.models.Album if rv.user_id == self.id).order_by(lambda: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5)) return albums[:limit] if category == 'all': albums = orm.select(rv for rv in collipa.models.Album if rv.user_id == self.id) else: albums = orm.select(rv for rv in collipa.models.Album if rv.user_id == self.id and rv.role == category) if order_by == 'created_at': albums = albums.order_by(lambda: orm.desc(rv.created_at)) elif order_by == 'up_count': albums = albums.order_by(lambda: orm.desc(rv.up_count)) elif order_by == 'thank_count': albums = albums.order_by(lambda: orm.desc(rv.thank_count)) elif order_by == 'smart': albums = albums.order_by(lambda: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5)) if page: return albums[(page - 1) * config.paged: page * config.paged] else: return albums
def album_list_id3(): ltype = request.values['type'] size, offset = map(request.values.get, [ 'size', 'offset' ]) size = int(size) if size else 10 offset = int(offset) if offset else 0 query = Album.select() if ltype == 'random': return request.formatter('albumList2', dict( album = [ a.as_subsonic_album(request.user) for a in query.random(size) ] )) elif ltype == 'newest': query = query.order_by(lambda a: desc(min(a.tracks.created))) elif ltype == 'frequent': query = query.order_by(lambda a: desc(avg(a.tracks.play_count))) elif ltype == 'recent': query = Album.select(lambda a: max(a.tracks.last_play) is not None).order_by(lambda a: desc(max(a.tracks.last_play))) elif ltype == 'starred': query = select(s.starred for s in StarredAlbum if s.user.id == request.user.id) elif ltype == 'alphabeticalByName': query = query.order_by(Album.name) elif ltype == 'alphabeticalByArtist': query = query.order_by(lambda a: a.artist.name + a.name) else: raise GenericError('Unknown search type') return request.formatter('albumList2', dict( album = [ f.as_subsonic_album(request.user) for f in query.limit(size, offset) ] ))
def album_list_id3(): ltype = request.values["type"] size, offset = map(request.values.get, ("size", "offset")) size = int(size) if size else 10 offset = int(offset) if offset else 0 query = Album.select() if ltype == "random": return request.formatter( "albumList2", { "album": [ a.as_subsonic_album(request.user) for a in query.random(size) ] }, ) elif ltype == "newest": query = query.order_by(lambda a: desc(min(a.tracks.created))) elif ltype == "frequent": query = query.order_by(lambda a: desc(avg(a.tracks.play_count))) elif ltype == "recent": query = Album.select( lambda a: max(a.tracks.last_play) is not None).order_by( lambda a: desc(max(a.tracks.last_play))) elif ltype == "starred": query = select(s.starred for s in StarredAlbum if s.user.id == request.user.id) elif ltype == "alphabeticalByName": query = query.order_by(Album.name) elif ltype == "alphabeticalByArtist": query = query.order_by(lambda a: a.artist.name + a.name) elif ltype == "byYear": startyear = int(request.values["fromYear"]) endyear = int(request.values["toYear"]) query = query.where(lambda a: between(min( a.tracks.year), min(startyear, endyear), max(startyear, endyear))) if endyear < startyear: query = query.order_by(lambda a: desc(min(a.tracks.year))) else: query = query.order_by(lambda a: min(a.tracks.year)) elif ltype == "byGenre": genre = request.values["genre"] query = query.where(lambda a: genre in a.tracks.genre) else: raise GenericError("Unknown search type") return request.formatter( "albumList2", { "album": [ f.as_subsonic_album(request.user) for f in query.limit(size, offset) ] }, )
def get_message_boxes(self, page=1, category='all'): if category == 'all': message_boxes = (collipa.models.MessageBox.select( lambda rv: rv.sender_id == self.id).order_by( lambda: orm.desc(rv.updated_at))) elif category == 'unread': message_boxes = (collipa.models.MessageBox.select( lambda rv: rv.sender_id == self.id and rv.status == 0). order_by(lambda: orm.desc(rv.updated_at))) else: return [] return message_boxes[(page - 1) * config.paged:page * config.paged]
def _previous(**kwargs): """ Get the previous item in any particular category """ spec = self._pagination_default_spec(kwargs) spec.update(kwargs) query = queries.build_query(spec) query = queries.where_before_entry(query, self._record) for record in query.order_by(orm.desc(model.Entry.local_date), orm.desc(model.Entry.id))[:1]: return Entry(record) return None
def get_created_by_user(self, id_): """Obtiene la lista de entidades de esta clase que han sido creadas por el usuario cuyo id se suministra. No funcionará correctamente si la clase no tiene campo 'creador'""" quien = model.Profesor.get(id=id_) if quien.role == "admin": return self.clase.select().order_by( desc(self.clase.fecha_modificacion)) creados = (self.clase.select(lambda p: p.creador == quien).order_by( desc(self.clase.fecha_modificacion))) print(creados) return creados
def show_home(): """ Homepage of the blog """ last = Articles.select().order_by(desc(Articles.timestamp)).first() lasts_art = Articles.select().order_by(desc(Articles.timestamp))[1:4] list_of_dict = [] for item in lasts_art: list_of_dict.append(fill_informations(item)) return render_template('blog/home.html', last=last, lasts=list_of_dict, socials=socials)
def get_nodes(page=1, category='all', limit=None): if category == 'all': nodes = orm.select(rv for rv in Node).order_by(lambda rv: orm.desc(rv.created_at)) elif category == 'hot': nodes = orm.select(rv for rv in Node).order_by(lambda rv: orm.desc(rv.topic_count)) elif category == 'new': nodes = orm.select(rv for rv in Node).order_by(lambda rv: orm.desc(rv.created_at)) if limit: return nodes[:limit] if page: return nodes[(page - 1) * config.node_paged: page * config.node_paged] else: return nodes
def get_message_boxes(self, page=1, category='all'): if category == 'all': message_boxes = (collipa.models.MessageBox .select(lambda rv: rv.sender_id == self.id) .order_by(lambda: orm.desc(rv.updated_at))) elif category == 'unread': message_boxes = (collipa.models.MessageBox .select(lambda rv: rv.sender_id == self.id and rv.status == 0) .order_by(lambda: orm.desc(rv.updated_at))) else: return [] return message_boxes[(page - 1) * config.paged: page * config.paged]
def most_integral(): """ 各小组晋级的前两名,排名优先级:积分、净胜球、球队名) """ _data = [] for g in GROUPS: res = orm.select(x for x in TeamDetails if x.t_group == g).order_by( orm.desc(TeamDetails.t_integral), orm.desc(TeamDetails.t_goal_difference), orm.desc(TeamDetails.t_team), ) lst = [(r.t_team, r.t_integral) for i, r in enumerate(res) if i < 2] _data.append({g: lst}) return _data
def get_timeline(self, page=1, from_id=None, count=config.paged): user_ids = self.followed_user_ids[:] or [0] user_ids.append(self.id) if not from_id: tweets = (orm.select(rv for rv in collipa.models.Tweet if rv.user_id in user_ids) .order_by(lambda: orm.desc(rv.created_at)) [(page - 1) * config.paged: page * config.paged]) return tweets all_ids_q = orm.select(rv.id for rv in collipa.models.Tweet if rv.user_id in user_ids).order_by(lambda: orm.desc(rv.created_at)) tweet_ids = collect_items_from_query(all_ids_q, from_id, count) return orm.select(rv for rv in collipa.models.Tweet if rv.id in tweet_ids)[:][::-1]
def get_topics(self, page=1, category='all', order_by='created_at'): if category == 'all': topics = orm.select(rv for rv in collipa.models.Topic if rv.node_id == self.id) order_by = 'last_reply_date' else: if category == 'hot': topics = mc.get('node_%s_hot_topics' % self.id) if not topics: now = int(time.time()) ago = now - 60 * 60 * 24 topics = orm.select( rv for rv in collipa.models.Topic if rv.node_id == self.id and rv.created_at > ago) topics = topics.order_by(lambda: orm.desc( (rv.collect_count + rv.thank_count - rv.report_count ) * 10 + (rv.up_count - rv.down_count ) * 5 + rv.reply_count * 3)) mc.set('node_%s_hot_topics' % self.id, list(topics), 60 * 60 * 3) order_by = 'none' elif category == 'latest': topics = orm.select(rv for rv in collipa.models.Topic if rv.node_id == self.id) elif category == 'desert': topics = orm.select( rv for rv in collipa.models.Topic if rv.node_id == self.id and rv.reply_count == 0) else: topics = orm.select( rv for rv in collipa.models.Topic if rv.node_id == self.id and rv.role == category) order_by = 'last_reply_date' if order_by == 'last_reply_date': topics = topics.order_by(lambda: orm.desc(rv.last_reply_date)) elif order_by == 'created_at': topics = topics.order_by(lambda: orm.desc(rv.created_at)) elif order_by == 'active': topics = topics.order_by(lambda: orm.desc(rv.active)) elif order_by == 'smart': topics = topics.order_by(lambda: orm.desc( (rv.collect_count + rv.thank_count - rv.report_count) * 10 + (rv.up_count - rv.down_count) * 5 + rv.reply_count * 3)) if page: return topics[(page - 1) * config.paged:page * config.paged] else: return topics
def get_topics(self, page=1, category='all', order_by='created_at'): if category == 'all': topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id) order_by = 'last_reply_date' else: if category == 'hot': topics = mc.get('node_%s_hot_topics' % self.id) if not topics: now = int(time.time()) ago = now - 60 * 60 * 24 topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id and rv.created_at > ago) topics = topics.order_by(lambda rv: orm.desc((rv.collect_count + rv.thank_count - rv.report_count) * 10 + (rv.up_count - rv.down_count) * 5 + rv.reply_count * 3)) mc.set('node_%s_hot_topics' % self.id, list(topics), 60 * 60 * 3) order_by = 'none' elif category == 'latest': topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id) elif category == 'desert': topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id and rv.reply_count == 0) else: topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id and rv.role == category) order_by = 'last_reply_date' if order_by == 'last_reply_date': topics = topics.order_by(lambda rv: orm.desc(rv.last_reply_date)) elif order_by == 'created_at': topics = topics.order_by(lambda rv: orm.desc(rv.created_at)) elif order_by == 'active': topics = topics.order_by(lambda rv: orm.desc(rv.active)) elif order_by == 'smart': topics = topics.order_by(lambda rv: orm.desc((rv.collect_count + rv.thank_count - rv.report_count) * 10 + (rv.up_count - rv.down_count) * 5 + rv.reply_count * 3)) if page: return topics[(page - 1) * config.paged: page * config.paged] else: return topics
def GetNotes(code, text=u'', creation=False): if code is None and creation: return select(note for note in Note if text in note.text).order_by(desc(Note.id)) elif code is None: return select(note for note in Note if text in note.text).order_by( Note.volume, Note.page) elif creation: return select(note for note in Note if note.code == code and text in note.text).order_by( desc(Note.id)) else: return select(note for note in Note if note.code == code and text in note.text).order_by( Note.volume, Note.page)
def verify(self, reprocess, action, mute=False): """Verify roos until we have one last good roo""" with db_session: offset = 0 good = False while not good: q = select(s for s in Switcharoo).order_by( desc(Switcharoo.time)).limit(10, offset) if len(q) == 0: good = True break for roo in q: self._link_reddit(roo) # Maybe use check_errors here instead now? tracker = reprocess(self.reddit, roo, self, action, mute=mute, verbose=False) if tracker: if not tracker.has_bad_issues(): good = True break offset += 10
def last_good(self, before_roo=None, offset=0, user=None, all=False): time = before_roo.time if before_roo else datetime.now() roo = None with db_session: q = select( s for s in Switcharoo if True not in s.issues.bad and s.link_post and s.time < time) # SQLite, I love you but why if self.db_type == "sqlite" and before_roo: q = q.filter(lambda x: x.id != before_roo.id) if user: q = q.filter(lambda x: x.user == user) q = q.order_by(desc(Switcharoo.time)).limit(limit=1, offset=offset) if q: if all: roo = list(q) else: roo = q[0] if roo: if all: for i in roo: self._link_reddit(i) else: self._link_reddit(roo) return roo
def category(category_name): with orm.db_session: return [ mappers.log(l) for l in models.CultureLog.select(lambda l: l.category.lower( ) == category_name).sort_by(orm.desc(models.CultureLog.event_date)) ]
def _query_recents(self, annee): query = ( select(p for p in Page if p.activite.matiere.groupe.annee.id == annee) .order_by(desc(Page.modified)) .limit(50) ) # pragma: no cover_all return query
def get_articles_in_range(min, max): lasts_art = Articles.select().order_by(desc( Articles.timestamp))[min:max] list_of_dict = [] for item in lasts_art: list_of_dict.append(fill_informations(item)) return list_of_dict
def get_last_id_date(cls): try: date = TelegaMessaga.select().order_by(desc( TelegaMessaga.date))[:1][0] except Exception: date = datetime(2007, 12, 6) return date
def jobsearch(): form = SearchForm(request.form) with orm.db_session: prevmaps = orm.select(c.departure for c in Direction).prefetch(Airport)[:] logs = Log.select(lambda p: p.country != 'AIR').order_by( orm.desc(Log.id))[:] if request.method == 'GET': keyword = request.args.get('k', '') country = request.args.get('c', '') if keyword == '': return renderform(form, logs, prevmaps) else: return renderjobs(kw=keyword, country=country) else: if form.validate_on_submit(): keyword = form.keyword.data country = form.country.data #if keyword==logs[0].keyword and logs[0].dt+timedelta(hours=1)>datetime.now(): if keyword == logs[0].keyword and logs[0].dt + timedelta( seconds=1) > datetime.now(): return renderjobs(kw=keyword, country=country) else: return renderjobs(kw=keyword, country=country, isrefresh=True) else: return renderform(form, logs, prevmaps)
def get_cell_history(token: str, cell_id: int, res: Response, with_closed: bool = False): token_user, error, code = get_user_by_token(token) if error: res.status_code = code return error l = [ x.to_dict() for x in select( t for t in Lease if t.is_returned in (with_closed, False) and t.cell_id.id == cell_id).order_by(lambda y: desc(y.start_time))[:] ] history = [] for lease in l: curr = lease.copy() try: u = User[curr["user_id"]] curr["user_name"] = u.first_name curr["user_surname"] = u.last_name curr["user_email"] = u.email except RowNotFound: curr["user_name"], curr["user_surname"], curr["user_email"] = ( None, None, None, ) history.append(curr) return history
def get_replies(self, page=1, category='all', order_by='created_at', limit=None): if category == 'all': replies = collipa.models.Reply.select(lambda rv: rv.topic_id == self.id) else: if category == 'hot': replies = collipa.models.Reply.select(lambda rv: rv.topic_id == self.id) limit = 10 order_by = 'smart' elif category == 'author': replies = orm.select(rv for rv in collipa.models.Reply if rv.topic_id == self.id and rv.user_id == self.user_id) else: replies = orm.select(rv for rv in collipa.models.Reply if rv.topic_id == self.id and rv.role == category) if order_by == 'smart': replies = replies.order_by(lambda: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5)) else: replies = replies.order_by(lambda: rv.created_at) if limit: return replies[:limit] elif page: return replies[(page - 1) * config.reply_paged: page * config.reply_paged] else: return replies
def index(self): '''Get all people, ordered by creation date.''' all_people = orm.select(p for p in Person).order_by( orm.desc(Person.created))[:] data = PersonSerializer(all_people, many=True, exclude=('created', )).data return jsonify({"people": data})
def datos_del_año(año): # Nombres más populares de ese año # Filtramos por prefijo filtrado = orm.select(n for n in Dato if n.año == año).order_by( orm.desc(Dato.contador) )[:50] return filtrado
def get_followers(self, page=1): follower_ids = orm.select(rv.who_id for rv in m.Follow if rv.whom_id == self.id).order_by(lambda rv: orm.desc(rv)) or [0] followers = orm.select(rv for rv in User if rv.id in follower_ids) if page: return followers[(page - 1) * config.user_paged: page * config.user_paged] else: return followers
def answer(): page = request.args.get('page', 1, int) answers_query = select(a for a in Answer).order_by(desc(Answer.vote_up)) answers = answers_query.page(page, pagesize=LIMIT) pagination = get_pagination(answers_query.count(), LIMIT, page) return render_template('answer/index.html', answers=answers, pagination=pagination)
def get_notifications(self, page=1, category='all'): if category == 'all': notifications = m.Notification.select(lambda rv: rv.receiver_id == self.id) elif category == 'unread': notifications = m.Notification.select(lambda rv: rv.receiver_id == self.id and rv.status == 0) notifications = notifications.order_by(lambda rv: orm.desc(rv.updated_at)) return notifications[(page - 1) * config.paged: page * config.paged]
def get_followings(self, page=1): following_ids = (orm.select(rv.whom_id for rv in collipa.models.Follow if rv.who_id == self.id and rv.whom_id) .order_by(lambda: orm.desc(rv.created_at)) or [0]) followings = orm.select(rv for rv in User if rv.id in following_ids) if page: return followings[(page - 1) * config.user_paged: page * config.user_paged] else: return followings
def question(): page = request.args.get('page', 1, int) questions_query = select(a for a in Question).order_by(desc(Question.answer_count)) questions = questions_query.page(page, pagesize=LIMIT) pagination = get_pagination(questions_query.count(), LIMIT, page) return render_template('question/index.html', questions=questions, pagination=pagination)
def collection(): page = request.args.get('page', 1, int) collections_query = select(c for c in Collection).order_by(desc(Collection.review_count)) collections = collections_query.page(page, pagesize=LIMIT) pagination = get_pagination(collections_query.count(), LIMIT, page) return render_template('collection/index.html', collections=collections, pagination=pagination)
def get_followed_topics(self, role=None, category='all', order_by='created_at', page=1): node_ids = self.followed_node_ids user_ids = self.followed_user_ids if not node_ids: node_ids = [0] if not user_ids: user_ids = [0] if category == 'hot': now = int(time.time()) ago = now - 60 * 60 * 24 try: return orm.select(rv for rv in collipa.models.Topic if (rv.node_id in node_ids or rv.user_id in user_ids) and rv.created_at > ago).order_by(lambda: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5)) except: return None elif category == 'all': topics = orm.select(rv for rv in collipa.models.Topic if rv.node_id in node_ids or rv.user_id in user_ids) elif category == 'user': topics = orm.select(rv for rv in collipa.models.Topic if rv.user_id in user_ids) elif category == 'node': topics = orm.select(rv for rv in collipa.models.Topic if rv.node_id in node_ids) else: return [] if order_by == 'smart': topics = topics.order_by(lambda: orm.desc((rv.collect_count + rv.thank_count) * 10 + (rv.up_count - rv.down_count) * 5 + rv.active / 4)) else: topics = topics.order_by(lambda: orm.desc(rv.last_reply_date)) if page: return topics[(page - 1) * config.paged: page * config.paged] else: return topics
def feed(): rendered = cache.get("rss_feed") if rendered is None: posts = orm.select(p for p in Post if p.draft is False).order_by(orm.desc(Post.posted)).limit(10) rendered = render_template('index.xml', posts=posts) cache.set("rss_feed", rendered) response = make_response(rendered) response.mimetype = "application/xml" return response
def author(): page = request.args.get('page', 1, int) authors_query = select(a for a in Author).order_by(desc(Author.id)) authors = authors_query.page(page, pagesize=LIMIT) pagination = get_pagination(authors_query.count(), LIMIT, page) return render_template('author/index.html', authors=authors, pagination=pagination)
def get_timeline(page=1, from_id=None, user_id=None, count=config.paged): if not from_id: if not user_id: tweets = (orm.select(rv for rv in Tweet) .order_by(lambda: orm.desc(rv.created_at)) [(page - 1) * count: page * count]) else: tweets = (orm.select(rv for rv in Tweet if rv.user_id == user_id) .order_by(lambda: orm.desc(rv.created_at)) [(page - 1) * count: page * count]) else: if not user_id: tweets = (orm.select(rv for rv in collipa.models.Tweet if rv.id < from_id) .order_by(lambda: orm.desc(rv.created_at)) [:count]) else: tweets = (orm.select(rv for rv in collipa.models.Tweet if rv.id < from_id and rv.user_id == user_id) .order_by(lambda: orm.desc(rv.created_at)) [:count]) return tweets
def get(self): page = force_int(self.get_argument('page', 1), 1) category = self.get_argument('category', None) view = self.get_argument('view', 'all') user = self.current_user if not category: category = self.index_category else: self.set_index_category(category) if category == 'timeline' and not user: category = self.set_index_category('index') if category == 'hot': topics = mc.get('hot_topics') if not topics: now = int(time.time()) ago = now - 60 * 60 * 24 topics = orm.select(rv for rv in Topic if rv.created_at > ago).order_by(lambda: orm.desc((rv.collect_count + rv.thank_count - rv.report_count) * 10 + (rv.up_count - rv.down_count) * 5 + rv.reply_count * 3)) mc.set('hot_topics', list(topics), 60 * 60 * 2) elif category == 'timeline': topics = user.get_followed_topics(page=None, category=view) elif category == 'latest': topics = orm.select(rv for rv in Topic).order_by(lambda: orm.desc(rv.created_at)) elif category == 'desert': topics = orm.select(rv for rv in Topic if rv.reply_count == 0).order_by(lambda: orm.desc(rv.created_at)) else: topics = orm.select(rv for rv in Topic).order_by(lambda: orm.desc(rv.last_reply_date)) if isinstance(topics, list): topic_count = len(topics) else: topic_count = orm.count(topics) topics = topics[(page - 1) * config.paged: page * config.paged] page_count = (topic_count + config.paged - 1) // config.paged return self.render("site/index.html", topics=topics, category=category, page=page, view=view, page_count=page_count, url='/')
def get_thankers(self, after_date=None, before_date=None): if after_date: user_ids = orm.select(rv.user_id for rv in m.Thank if rv.topic_id == self.id and rv.created_at > after_date) elif before_date: user_ids = orm.select(rv.user_id for rv in m.Thank if rv.topic_id == self.id and rv.created_at < before_date) else: user_ids = orm.select(rv.user_id for rv in m.Thank if rv.topic_id == self.id) users = [] if user_ids: user_ids = user_ids.order_by(lambda rv: orm.desc(rv.created_at)) users = orm.select(rv for rv in m.User if rv.id in user_ids) return users
def get_uppers(self, after_date=None, before_date=None): if after_date: user_ids = orm.select(rv.user_id for rv in collipa.models.Up if rv.album_id == self.id and rv.created_at > after_date) elif before_date: user_ids = orm.select(rv.user_id for rv in collipa.models.Up if rv.album_id == self.id and rv.created_at < before_date) else: user_ids = orm.select(rv.user_id for rv in collipa.models.Up if rv.album_id == self.id) users = [] if user_ids: user_ids = user_ids.order_by(lambda: orm.desc(rv.created_at)) users = orm.select(rv for rv in collipa.models.User if rv.id in user_ids) return users
def get_timeline(self, page=1, from_id=None, count=config.paged): user_ids = self.followed_user_ids[:] or [0] user_ids.append(self.id) if not from_id: tweets = orm.select(rv for rv in m.Tweet if rv.user_id in user_ids).order_by(lambda rv: orm.desc(rv.created_at))[(page - 1) * config.paged: page * config.paged] return tweets all_ids = orm.select(rv.id for rv in m.Tweet if rv.user_id in user_ids).order_by(lambda rv: orm.desc(rv.created_at)) i = -1 for i, _id in enumerate(all_ids): if i == 1000: return [] if _id == from_id: break tweet_ids = all_ids[i + 1: i + 1 + count] if tweet_ids: tweets = orm.select(rv for rv in m.Tweet if rv.id in tweet_ids)[:][::-1] else: tweets = [] return tweets
def query_by_album_id(album_id, from_id=None, limit=config.paged, desc=True): q = orm.select(rv for rv in Image if rv.album_id == album_id) if desc: q = q.order_by(lambda: orm.desc(rv.created_at)) else: q = q.order_by(lambda: rv.created_at) if from_id: return helpers.collect_items_from_query(q, from_id, limit, "id") if limit: return q[:limit] return q[:]
def index(): special_pages = [] posts_qs = orm.select(p for p in Post if p.draft is False).order_by(orm.desc(Post.posted)) try: start_page = int(request.args.get("page", 1)) if start_page < 1: start_page = 1 except ValueError: start_page = 1 pag = Pagination(start_page, 5, posts_qs.count()) posts = posts_qs.limit(5, offset=pag.offset) return render_template("index.html", posts=posts, paginator=pag, title=app.config["SITE_TITLE"], show_header=True, special_pages=special_pages)
def query_by_album_id(album_id, from_id=None, limit=None, desc=True): limit = limit or config.paged images = orm.select(rv for rv in Image if rv.album_id == album_id) if desc: images = images.order_by(lambda rv: orm.desc(rv.created_at)) else: images = images.order_by(lambda rv: rv.created_at) if from_id: i = -1 for i, image in enumerate(images): if i == 1000: return [] if image.id == from_id: break images = images[i + 1: i + 1 + limit] return images return images
def callback_query(bot, update): cb = update.callback_query chat_id = cb.message.chat_id data = update.callback_query.data logger.info(data) data = data.split('%') action = '' offset = 0 disabled_attachments = set() query = '' confirmed = False show_download = True for elem in data: name, *args = elem.split('=') if name == 'act': action = args[0] elif name == 'off': offset = int(args[0]) elif name == 'noatt': disabled_attachments = set(int(arg) for arg in args if arg != '') elif name == 'qry': query = '='.join(args) elif name == 'cnf': confirmed = bool(int(args[0])) elif name == 'dl': show_download = bool(int(args[0])) reporter = get_reporter(cb.from_user) if action == 'old': new_offset = offset + 1 elif action == 'new': new_offset = offset - 1 else: new_offset = offset try: scammers = select( s for s in Scammer if query in s.phone_nr or query in s.account_nr or query in s.bank_name or query in s.remark ).order_by( desc(Scammer.created) )[new_offset:new_offset + 1] except TypeError: scammers = None else: offset = new_offset reply = None if action in ('old', 'new'): if scammers: scammer = scammers[0] reply = str(scammer) if not scammer.attached_file: disabled_attachments.add(offset) confirmed = reporter in scammer.reported_by if reporter else False else: bot.answerCallbackQuery(callback_query_id=cb.id, text="No more results") return elif action == 'confirm': if not scammers: bot.answerCallbackQuery(callback_query_id=cb.id, text="Not found, please search again") return scammer = scammers[0] if not confirmed: if not reporter: reporter = Reporter(id=cb.from_user.id, first_name=cb.from_user.first_name, last_name=cb.from_user.last_name, username=cb.from_user.username) track(update, 'new_reporter') scammer.reported_by.add(reporter) bot.answerCallbackQuery(callback_query_id=cb.id, text="You confirmed this report.") else: scammer.reported_by.remove(reporter) bot.answerCallbackQuery(callback_query_id=cb.id, text="You removed your confirmation.") confirmed = not confirmed reply = str(scammer) elif action == 'att': if not scammers: bot.answerCallbackQuery(callback_query_id=cb.id, text="Not found, please search again") return kind, _, file_id = scammers[0].attached_file.partition(':') if kind == 'photo': bot.sendPhoto(chat_id, photo=file_id, reply_to_message_id=cb.message.message_id) elif kind == 'document': bot.sendDocument(chat_id, document=file_id, reply_to_message_id=cb.message.message_id) disabled_attachments.add(offset) elif action == 'dl': bot.sendChatAction(chat_id, action=ChatAction.UPLOAD_DOCUMENT) with db_session: scammers = select(s for s in Scammer if query in s.phone_nr or query in s.account_nr or query in s.bank_name or query in s.remark).limit(100) content = "\r\n\r\n".join(str(s) for s in scammers) file = BytesIO(content.encode()) show_download = False bot.sendDocument(chat_id, document=BufferedReader(file), filename='search.txt', reply_to_message_id=update.callback_query.message.message_id) kb = search_keyboard(offset=offset, show_download=show_download, disabled_attachments=disabled_attachments, confirmed=confirmed, query=query) reply_markup = InlineKeyboardMarkup(kb) if reply: bot.editMessageText(chat_id=chat_id, message_id=cb.message.message_id, text=reply, reply_markup=reply_markup, parse_mode=ParseMode.HTML) else: bot.editMessageReplyMarkup(chat_id=chat_id, message_id=update.callback_query.message.message_id, reply_markup=reply_markup)