def __init__(self, db, name, parent): Container.__init__(self, parent, convertString(name)) self._db = db self.location = None self.item = None self.children = None self._child_count = -1 self._default_mime = "audio/*" self._default_additionalInfo = "*"
def upnp_init(self):
if self.server:
self.server.connection_manager_server.set_variable(0, 'SourceProtocolInfo',
['http-get:*:%s:*' % MPEG_MIME],
default=True)
# root item
root_item = Container(None, self.name)
self.set_root_item(root_item)
# 'Following' directory
settings = self.config.get('Following', {})
if self.access_token and settings.get('active') != 'no':
games_dir = StreamsContainer(root_item,
title=settings.get('name') or 'Following',
streams_url='%s/streams/followed',
limit=settings.get('limit', 25),
oauth_token=self.access_token)
root_item.add_child(games_dir)
# 'Games' directory
settings = self.config.get('TopGames', {})
if settings.get('active') != 'no':
games_dir = GamesContainer(root_item,
title=settings.get('name', 'Top Games'),
limit=settings.get('limit', 10),
children_limit=settings.get('children_limit', 25))
root_item.add_child(games_dir)
# 'Top Streams' directory
settings = self.config.get('TopStreams', {})
if settings.get('active') != 'no':
games_dir = StreamsContainer(root_item,
title=settings.get('name', 'Top Streams'),
limit=settings.get('limit', 25))
root_item.add_child(games_dir)
def read_categories(data, parent_item, jukebox_url):
for category in data.findall('category'):
type = category.get('name')
category_title = type
if type != 'Other':
category_title = f'By {category_title}'
categoryItem = Container(parent_item, category_title)
parent_item.add_child(categoryItem)
for index in category.findall('./index'):
name = index.get('name')
first_filename = index.text
root_name = first_filename[:-2]
self.debug(f'adding index {type}:{name}')
parent = categoryItem
if type == 'Other':
parent = parent_item
indexItem = LazyContainer(
parent,
name,
None,
self.refresh,
self.retrieveIndexMovies,
per_page=1,
name=name,
root_name=root_name,
)
parent.add_child(indexItem)
self.init_completed()
def read_categories(data, parent_item, jukebox_url):
#nbMoviesPerFile = 1 #int(data.find('preferences/mjb.nbThumbnailsPerPage').text)
#self.debug("YMAJ: Nb Movies per file = %s" % nbMoviesPerFile)
for category in data.findall('category'):
type = category.get('name')
category_title = type
if (type != 'Other'):
category_title = "By %s" % category_title
categoryItem = Container(parent_item, category_title)
parent_item.add_child(categoryItem)
for index in category.findall('./index'):
name = index.get('name')
first_filename = index.text
root_name = first_filename[:-2]
self.debug("adding index %s:%s" % (type, name))
parent = categoryItem
if (type == 'Other'):
parent = parent_item
indexItem = LazyContainer(parent,
name,
None,
self.refresh,
self.retrieveIndexMovies,
per_page=1,
name=name,
root_name=root_name)
parent.add_child(indexItem)
self.init_completed()
def __init__(self, server, **kwargs):
AbstractBackendStore.__init__(self, server, **kwargs)
self.name = kwargs.get('name', 'Picasa Web Albums')
self.refresh = int(kwargs.get('refresh', 60)) * 60
self.login = kwargs.get('userid', kwargs.get('login', ''))
self.password = kwargs.get('password', '')
rootContainer = Container(None, self.name)
self.set_root_item(rootContainer)
self.AlbumsContainer = LazyContainer(rootContainer, 'My Albums', None,
self.refresh, self.retrieveAlbums)
rootContainer.add_child(self.AlbumsContainer)
self.FeaturedContainer = LazyContainer(
rootContainer,
'Featured photos',
None,
self.refresh,
self.retrieveFeaturedPhotos,
)
rootContainer.add_child(self.FeaturedContainer)
self.init_completed()
def __init__(self, server, **kwargs):
AbstractBackendStore.__init__(self, server, **kwargs)
self.name = kwargs.get('name', 'iRadioStore')
self.refresh = int(kwargs.get('refresh', 60)) * 60
self.shoutcast_ws_url = self.config.get(
'genrelist',
SC_URL_GENRE_LIST.format(api_url=SC_API_URL, key=SC_KEY),
)
# set root item
root_item = Container(None, self.name)
self.set_root_item(root_item)
# set root-level genre family containers and populate the genre_
# parent_items dict from the family hierarchy information
for family, genres in list(genre_families.items()):
family_item = self.append_genre(root_item, family)
if family_item is not None:
self.genre_parent_items[family] = root_item
for genre in genres:
self.genre_parent_items[genre] = family_item
# retrieve asynchronously the list of genres from
# the souhtcast server genres not already attached to
# a family will be attached to the 'Misc' family
self.retrieveGenreList_attemptCount = 0
deferredRoot = self.retrieveGenreList()
def readIndex(data):
for index in data.findall('category/index'):
current = index.get('current')
if (current == "true"):
currentIndex = index.get('currentIndex')
lastIndex = index.get('lastIndex')
if (currentIndex != lastIndex):
parent.childrenRetrievingNeeded = True
self.debug("%s: %s/%s", root_name, currentIndex, lastIndex)
break
movies = data.findall('movies/movie')
if self.nbMoviesPerFile is None:
self.nbMoviesPerFile = len(movies)
for movie in movies:
isSet = (movie.attrib['isSet'] == 'true')
if isSet is True:
# the movie corresponds to a set
name = movie.find('./title').text
index_name = movie.find('./baseFilename').text
set_root_name = index_name[:-2]
self.debug("adding set %s", name)
indexItem = LazyContainer(parent, name, None, self.refresh, self.retrieveIndexMovies, per_page=1, name=name, root_name=set_root_name)
parent.add_child(indexItem, set_root_name)
else:
# this is a real movie
movie_id = "UNK"
movie_id_xml = movie.find('./id')
if movie_id_xml is not None:
movie_id = movie_id_xml.text
files = movie.findall('./files/file')
if (len(files) == 1):
url = files[0].find('./fileURL').text
external_id = "%s/%s" % (movie_id, url)
movieItem = MovieItem(movie, self)
parent.add_child(movieItem, external_id)
else:
name = movie.find('./title').text
if name is None or name == '':
name = movie.find('./baseFilename').text
season = movie.find('season').text
if season is not None and season != '-1':
name = "%s - season %s" % (name, season)
container_item = Container(parent, name)
parent.add_child(container_item, name)
container_item.store = self
for file in files:
episodeIndex = file.attrib['firstPart']
episodeTitle = file.attrib['title']
if (episodeTitle == 'UNKNOWN'):
title = "%s - %s" % (name, episodeIndex)
else:
title = "%s - %s " % (episodeIndex, episodeTitle)
episodeUrl = file.find('./fileURL').text
fileItem = MovieItem(movie, self, title=title, url=episodeUrl)
file_external_id = "%s/%s" % (movie_id, episodeUrl)
container_item.add_child(fileItem, file_external_id)
def upnp_init(self):
self.current_connection_id = None
if self.server:
self.server.connection_manager_server.set_variable(
0,
'SourceProtocolInfo', [
'rtsp-rtp-udp:*:video/mpeg:*', 'http-get:*:video/mpeg:*',
'rtsp-rtp-udp:*:audio/mpeg:*', 'http-get:*:audio/mpeg:*'
],
default=True)
rootItem = Container(None, self.name)
self.set_root_item(rootItem)
return self.retrievePlaylistItems(self.playlist_url, rootItem)
def __init__(self, server, **kwargs):
AbstractBackendStore.__init__(self, server, **kwargs)
self.name = kwargs.get('name', 'YAMJ')
self.yamj_url = kwargs.get('yamj_url', 'http://localhost/yamj')
self.jukebox_url = self.yamj_url + '/Jukebox/'
self.refresh = int(kwargs.get('refresh', 60)) * 60
self.nbMoviesPerFile = None
rootItem = Container(None, self.name)
self.set_root_item(rootItem)
d = self.retrieveCategories(rootItem)
def extractAudioCdInfo(self):
""" extract the CD info (album art + artist + tracks), and construct the UPnP items"""
self.cdrom = DiscID.open(self.device_name)
disc_id = DiscID.disc_id(self.cdrom)
(query_status, query_info) = CDDB.query(disc_id)
if query_status in (210, 211):
query_info = query_info[0]
(read_status, read_info) = CDDB.read(query_info['category'],
query_info['disc_id'])
# print query_info['title']
# print disc_id[1]
# for i in range(disc_id[1]):
# print "Track %.02d: %s" % (i, read_info['TTITLE' + `i`])
track_count = disc_id[1]
disc_id = query_info['disc_id']
self.disc_title = query_info['title'].encode('utf-8')
tracks = {}
for i in range(track_count):
tracks[i +
1] = read_info['TTITLE' +
` i `].decode('ISO-8859-1').encode('utf-8')
self.name = self.disc_title
root_item = Container(None, self.disc_title)
# we will sort the item by "track_number"
def childs_sort(x, y):
return cmp(x.track_number, y.track_number)
root_item.sorting_method = childs_sort
self.set_root_item(root_item)
for number, title in tracks.items():
item = TrackItem(self.device_name, number, "Unknown", title)
external_id = "%s_%d" % (disc_id, number)
root_item.add_child(item, external_id=external_id)
self.info('Sharing audio CD %s' % self.disc_title)
reactor.callLater(2, self.checkIfAudioCdStillPresent)
self.init_completed()
def append_outline(parent, outline):
type = outline.get('type')
outline_url = outline.get('URL', None)
if type is None:
# This outline is just a classification item containing
# other outline elements the corresponding item
# will a static Container
text = outline.get('text')
key = outline.get('key')
external_id = None
if external_id is None and key is not None:
external_id = f'{parent.external_id}_{key}'
if external_id is None:
external_id = outline_url
item = Container(parent, text)
item.external_id = external_id
item.store = parent.store
parent.add_child(item, external_id=external_id)
sub_outlines = outline.findall('outline')
for sub_outline in sub_outlines:
append_outline(item, sub_outline)
elif type == 'link':
# the corresponding item will a self-populating Container
text = outline.get('text')
key = outline.get('key')
guide_id = outline.get('guide_id')
external_id = guide_id
if external_id is None and key is not None:
external_id = f'{parent.external_id}_{key}'
if external_id is None:
external_id = outline_url
item = LazyContainer(
parent,
text,
external_id,
self.refresh,
self.retrieveItemsForOPML,
url=outline_url,
)
parent.add_child(item, external_id=external_id)
elif type == 'audio':
item = RadiotimeAudioItem(outline)
parent.add_child(item, external_id=item.preset_id)
def extractAudioCdInfo(self):
'''
extract the CD info (album art + artist + tracks),
and construct the UPnP items
'''
self.cdrom = DiscID.open(self.device_name)
disc_id = DiscID.disc_id(self.cdrom)
(query_status, query_info) = CDDB.query(disc_id)
if query_status in (210, 211):
query_info = query_info[0]
(read_status, read_info) = CDDB.read(query_info['category'],
query_info['disc_id'])
# print(query_info['title'])
# print(disc_id[1])
# for i in range(disc_id[1]):
# print(f'Track {i:.02d}: {read_info["TTITLE" + repr(i)]}')
track_count = disc_id[1]
disc_id = query_info['disc_id']
self.disc_title = query_info['title'].encode('utf-8')
tracks = {}
for i in range(track_count):
tracks[i + 1] = (read_info[f'TTITLE{repr(i)}'].decode(
'ISO-8859-1').encode('utf-8'))
self.name = self.disc_title
root_item = Container(None, self.disc_title)
root_item.sorting_method = 'track_number'
self.set_root_item(root_item)
for number, title in list(tracks.items()):
item = TrackItem(self.device_name, number, 'Unknown', title)
external_id = f'{disc_id}_{number:d}'
root_item.add_child(item, external_id=external_id)
self.info('Sharing audio CD %s', self.disc_title)
reactor.callLater(2, self.checkIfAudioCdStillPresent)
self.init_completed()
def init_container_structure(self):
self.name = "Mbira"
root_item = Container(None, self.name)
self.set_root_item(root_item)
self.albumsContainer = Container(root_item, "Albums")
root_item.add_child(self.albumsContainer, external_id="Albums")
self.allTracksContainer = Container(root_item, "All tracks")
root_item.add_child(self.allTracksContainer, external_id="AllTracks")
self.artistsContainer = Container(root_item, "Artists")
root_item.add_child(self.artistsContainer, external_id="Artists")
genresContainer = Container(root_item, "Genres")
root_item.add_child(genresContainer, external_id="Genres")
playlistsContainer = Container(root_item, "Playlists")
root_item.add_child(playlistsContainer, external_id="Playlists")
def __init__(self, parent, title): Container.__init__(self, parent, title) self.service_number = 0 self.item = None self.location = "" self.children = None
def __init__(self, server, **kwargs):
AbstractBackendStore.__init__(self, server, **kwargs)
self.name = kwargs.get('name', 'MiroGuide')
self.language = kwargs.get('language', 'English')
self.refresh = int(kwargs.get('refresh', 60)) * 60
self.proxy_mode = kwargs.get('proxy_mode', 'redirect')
self.cache_directory = kwargs.get('cache_directory', '/tmp/coherence-cache')
try:
if self.proxy_mode != 'redirect':
os.mkdir(self.cache_directory)
except:
pass
self.cache_maxsize = kwargs.get('cache_maxsize', 100000000)
self.buffer_size = kwargs.get('buffer_size', 750000)
rootItem = Container(None, self.name)
self.set_root_item(rootItem)
categoriesItem = Container(rootItem, "All by Categories")
rootItem.add_child(categoriesItem)
languagesItem = Container(rootItem, "All by Languages")
rootItem.add_child(languagesItem)
self.appendLanguage("Recent Videos", self.language, rootItem, sort='-age', count=15)
self.appendLanguage("Top Rated", self.language, rootItem, sort='rating', count=15)
self.appendLanguage("Most Popular", self.language, rootItem, sort='-popular', count=15)
def gotError(error):
print("ERROR: %s" % error)
def gotCategories(result):
if result is None:
print("Unable to retrieve list of categories")
return
data, header = result
categories = eval(data) # FIXME add some checks to avoid code injection
for category in categories:
name = category['name'].encode('ascii', 'strict')
category_url = category['url'].encode('ascii', 'strict')
self.appendCategory(name, name, categoriesItem)
categories_url = "https://www.miroguide.com/api/list_categories"
d1 = utils.getPage(categories_url)
d1.addCallbacks(gotCategories, gotError)
def gotLanguages(result):
if result is None:
print("Unable to retrieve list of languages")
return
data, header = result
languages = eval(data) # FIXME add some checks to avoid code injection
for language in languages:
name = language['name'].encode('ascii', 'strict')
language_url = language['url'].encode('ascii', 'strict')
self.appendLanguage(name, name, languagesItem)
languages_url = "https://www.miroguide.com/api/list_languages"
d2 = utils.getPage(languages_url)
d2.addCallbacks(gotLanguages, gotError)
self.init_completed()
def readIndex(data):
for index in data.findall('category/index'):
current = index.get('current')
if current == 'true':
currentIndex = index.get('currentIndex')
lastIndex = index.get('lastIndex')
if currentIndex != lastIndex:
parent.childrenRetrievingNeeded = True
self.debug(f'{root_name}: {currentIndex}/{lastIndex}')
break
movies = data.findall('movies/movie')
if self.nbMoviesPerFile is None:
self.nbMoviesPerFile = len(movies)
for movie in movies:
isSet = movie.attrib['isSet'] == 'true'
if isSet is True:
# the movie corresponds to a set
name = movie.find('./title').text
index_name = movie.find('./baseFilename').text
set_root_name = index_name[:-2]
self.debug(f'adding set {name}')
indexItem = LazyContainer(
parent,
name,
None,
self.refresh,
self.retrieveIndexMovies,
per_page=1,
name=name,
root_name=set_root_name,
)
parent.add_child(indexItem, set_root_name)
else:
# this is a real movie
movie_id = 'UNK'
movie_id_xml = movie.find('./id')
if movie_id_xml is not None:
movie_id = movie_id_xml.text
files = movie.findall('./files/file')
if len(files) == 1:
url = files[0].find('./fileURL').text
external_id = f'{movie_id}/{url}'
movieItem = MovieItem(movie, self)
parent.add_child(movieItem, external_id)
else:
name = movie.find('./title').text
if name is None or name == '':
name = movie.find('./baseFilename').text
season = movie.find('season').text
if season is not None and season != '-1':
name = f'{name} - season {season}'
container_item = Container(parent, name)
parent.add_child(container_item, name)
container_item.store = self
for file in files:
episodeIndex = file.attrib['firstPart']
episodeTitle = file.attrib['title']
if episodeTitle == 'UNKNOWN':
title = f'{name} - {episodeIndex}'
else:
title = f'{episodeIndex} - {episodeTitle} '
episodeUrl = file.find('./fileURL').text
fileItem = MovieItem(movie,
self,
title=title,
url=episodeUrl)
file_external_id = f'{movie_id}/{episodeUrl}'
container_item.add_child(fileItem,
file_external_id)
def __init__(self, parent, artist):
Container.__init__(self, parent, artist[u"artist"][0])
self.artist = artist
def __init__(self, parent, album):
Container.__init__(self, parent, album[u"album"][0])
self.album = album
def __init__(self, parent, album):
Container.__init__(self, parent, album[u'album'][0])
self.album = album
def __init__(self, parent, artist):
Container.__init__(self, parent, artist[u'artist'][0])
self.artist = artist
