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)
