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 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 as_subsonic_child(self, user): info = dict( id = str(self.id), isDir = True, title = self.name, album = self.name, created = self.created.isoformat() ) if not self.root: info['parent'] = str(self.parent.id) info['artist'] = self.parent.name if self.cover_art: info['coverArt'] = str(self.id) try: starred = StarredFolder[user.id, self.id] info['starred'] = starred.date.isoformat() except ObjectNotFound: pass try: rating = RatingFolder[user.id, self.id] info['userRating'] = rating.rating except ObjectNotFound: pass avgRating = avg(self.ratings.rating) if avgRating: info['averageRating'] = avgRating return info
def as_subsonic_child(self, user, prefs): info = dict( id=str(self.id), parent=str(self.folder.id), isDir=False, title=self.title, album=self.album.name, artist=self.artist.name, track=self.number, size=os.path.getsize(self.path) if os.path.isfile(self.path) else -1, contentType=self.mimetype, suffix=self.suffix(), duration=self.duration, bitRate=self.bitrate, path=self.path[len(self.root_folder.path) + 1 :], isVideo=False, discNumber=self.disc, created=self.created.isoformat(), albumId=str(self.album.id), artistId=str(self.artist.id), type="music", ) if self.year: info["year"] = self.year if self.genre: info["genre"] = self.genre if self.has_art: info["coverArt"] = str(self.id) elif self.folder.cover_art: info["coverArt"] = str(self.folder.id) try: starred = StarredTrack[user.id, self.id] info["starred"] = starred.date.isoformat() except ObjectNotFound: pass try: rating = RatingTrack[user.id, self.id] info["userRating"] = rating.rating except ObjectNotFound: pass avgRating = avg(self.ratings.rating) if avgRating: info["averageRating"] = avgRating if ( prefs is not None and prefs.format is not None and prefs.format != self.suffix() ): info["transcodedSuffix"] = prefs.format info["transcodedContentType"] = ( mimetypes.guess_type("dummyname." + prefs.format, False)[0] or "application/octet-stream" ) return info
def as_subsonic_child(self, user): info = dict(id=str(self.id), isDir=True, title=self.name, album=self.name, created=self.created.isoformat()) if not self.root: info['parent'] = str(self.parent.id) info['artist'] = self.parent.name if self.cover_art: info['coverArt'] = str(self.id) else: for track in self.tracks: if track.has_art: info['coverArt'] = str(track.id) break try: starred = StarredFolder[user.id, self.id] info['starred'] = starred.date.isoformat() except ObjectNotFound: pass try: rating = RatingFolder[user.id, self.id] info['userRating'] = rating.rating except ObjectNotFound: pass avgRating = avg(self.ratings.rating) if avgRating: info['averageRating'] = avgRating return info
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(): 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)).distinct() 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 topCharsPerMessage(n: int=10, minMessages: int=30): statusFilter = ["left", "kicked", ""] data = select(( user, avg(len(x.text) for x in user.messages if len(x.text) > 0) ) for user in User if (count(user.messages) >= minMessages) and (user.lastStatus not in statusFilter) ).order_by(-2) return data.limit(n)
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 as_subsonic_child(self, user, prefs): info = { "id": str(self.id), "parent": str(self.folder.id), "isDir": False, "title": self.title, "album": self.album.name, "artist": self.artist.name, "track": self.number, "size": os.path.getsize(self.path) if os.path.isfile(self.path) else -1, "contentType": self.mimetype, "suffix": self.suffix(), "duration": self.duration, "bitRate": self.bitrate, "path": self.path[len(self.root_folder.path) + 1:], "isVideo": False, "discNumber": self.disc, "created": self.created.isoformat(), "albumId": str(self.album.id), "artistId": str(self.artist.id), "type": "music", } if self.year: info["year"] = self.year if self.genre: info["genre"] = self.genre if self.has_art: info["coverArt"] = str(self.id) elif self.folder.cover_art: info["coverArt"] = str(self.folder.id) try: starred = StarredTrack[user.id, self.id] info["starred"] = starred.date.isoformat() except ObjectNotFound: pass try: rating = RatingTrack[user.id, self.id] info["userRating"] = rating.rating except ObjectNotFound: pass avgRating = avg(self.ratings.rating) if avgRating: info["averageRating"] = avgRating if (prefs is not None and prefs.format is not None and prefs.format != self.suffix()): info["transcodedSuffix"] = prefs.format info["transcodedContentType"] = (mimetypes.guess_type( "dummyname." + prefs.format, False)[0] or "application/octet-stream") return info
def count_each_origins_destinations(): with pny.db_session: #oc = pny.select((o, pny.avg(t.duration)) for o in Origin ## for d in o.destinations # for t in d.trips if t.mode == "transit")[:] #dc = pny.select((d.origin, pny.avg(t.duration)) for d in Destination # for t in d.trips if t.mode == "transit").without_distinct()[:] #dc2 = pny.select((d.id, d.origin, pny.avg(t.duration)) for d in Destination # for t in d.trips if t.mode == "transit")[:] origins = pny.select((d.origin.location, pny.avg(t.duration for t in d.trips if t.mode == "transit"), pny.avg(t.duration for t in d.trips if t.mode == "driving")) for d in Destination)[:] print(len(origins)) origins = pny.select((o.location, pny.avg(t.duration for d in o.destinations for t in d.trips if t.mode == "driving"), pny.avg(t.duration for d in o.destinations for t in d.trips if t.mode == "transit")) for o in Origin)[:] print(len(origins)) # pny.select((d.id, d.origin, pny.avg(t.duration)) # for t in d.trips if t.mode == "transit"), # # pny.select((d.id, d.origin, t.duration) # for t in d.trips if t.mode == "driving") #print(len(oc)) #print(len(dc)) #print(len(dc2)) print("Query") fails = [] for i, o in enumerate(origins): print(i, o) print("\n".join(map(str, fails)))
def as_subsonic_child(self, user, prefs): info = dict( id = str(self.id), parent = str(self.folder.id), isDir = False, title = self.title, album = self.album.name, artist = self.artist.name, track = self.number, size = os.path.getsize(self.path) if os.path.isfile(self.path) else -1, contentType = self.mimetype, suffix = self.suffix(), duration = self.duration, bitRate = self.bitrate, path = self.path[len(self.root_folder.path) + 1:], isVideo = False, discNumber = self.disc, created = self.created.isoformat(), albumId = str(self.album.id), artistId = str(self.artist.id), type = 'music' ) if self.year: info['year'] = self.year if self.genre: info['genre'] = self.genre if self.has_art: info['coverArt'] = str(self.id) elif self.folder.cover_art: info['coverArt'] = str(self.folder.id) try: starred = StarredTrack[user.id, self.id] info['starred'] = starred.date.isoformat() except ObjectNotFound: pass try: rating = RatingTrack[user.id, self.id] info['userRating'] = rating.rating except ObjectNotFound: pass avgRating = avg(self.ratings.rating) if avgRating: info['averageRating'] = avgRating if prefs is not None and prefs.format is not None and prefs.format != self.suffix(): info['transcodedSuffix'] = prefs.format info['transcodedContentType'] = mimetypes.guess_type('dummyname.' + prefs.format, False)[0] or 'application/octet-stream' return info
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', 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 as_subsonic_child(self, user): info = { "id": str(self.id), "isDir": True, "title": self.name, "album": self.name, "created": self.created.isoformat(), } if not self.root: info["parent"] = str(self.parent.id) info["artist"] = self.parent.name if self.cover_art: info["coverArt"] = str(self.id) else: for track in self.tracks: if track.has_art: info["coverArt"] = str(track.id) break try: starred = StarredFolder[user.id, self.id] info["starred"] = starred.date.isoformat() except ObjectNotFound: pass try: rating = RatingFolder[user.id, self.id] info["userRating"] = rating.rating except ObjectNotFound: pass avgRating = avg(self.ratings.rating) if avgRating: info["averageRating"] = avgRating return info
def charsPerMessage(user): return avg(len(x.text) for x in user.messages if len(x.text) > 0)
def get(self): logger = logging.getLogger('PTA.flask.get_all_origins_voronoi') logger.info("Start") # Get info from DB retrycount = 3 for _ in range(retrycount): try: logger.info("Fetch from DB") with pny.db_session: origins = pny.select((o.location, pny.avg(t.duration for d in o.destinations for t in d.trips if t.mode == "driving"), pny.avg(t.duration for d in o.destinations for t in d.trips if t.mode == "transit")) for o in Origin)[:] logger.info("DB access went OK.") break except ValueError as ve: properties = { "isOrigin": True, "location": "error! reload page." } f = geojson.Feature(geometry=geojson.Point((151.2, -33.9)), properties=properties) logger.info("DB fetch failed, returning error point.") return geojson.FeatureCollection([ f, ]) except pny.core.RollbackException as re: logger.error("Bad DB hit. Retrying:\n{}".format(re)) else: logger.error("DB failed bigtime.") # TODO: deal with this error logger.info("Preparing GeoJSON with Voronoi") opoints = [o[0].split(",")[::-1] for o in origins] features = [] # Plot the origin map try: regions, vertices = get_voronoi_map(opoints) for i, region in enumerate(regions): try: ratio = origins[i][1] / origins[i][2] except Exception as e: print(e) ratio = -1 properties = { "isOPoly": True, "ratio": ratio, "location": origins[i][0] } points = [(lon, lat) for lon, lat in vertices[region] ] # TODO: do some rounding to save bandwidth points.append(points[0]) # close off the polygon features.append( geojson.Feature( geometry=geojson.Polygon([points]), properties=properties, )) except ValueError as ve: logger.error( "Voronoi function failed. Only sending destinations. Error: {}" .format(ve)) logger.info("GeoJSON built.") return geojson.FeatureCollection(features)