def __init__(self, item_data, container): BackendItem.__init__(self) self.item_data = item_data self.container = container self.sub_id = item_data["sub_id"] self.storage_id = "track-%s$%s" % (self.sub_id, container.get_id()) self.__class__.next_sn += 1 self.sort_key = self.__class__.next_sn track_number = None m = re.match( r"^song\.(\d+)\s+.*$", _htmlparser.unescape(item_data["title"]), re.I, ) if m: track_number, = m.groups() title = _htmlparser.unescape(item_data["sub_title"]) self.name = title self.title = title self.originalTrackNumber = track_number self.artist = _htmlparser.unescape(item_data["artist"]) self.album = _htmlparser.unescape(item_data["wiki_title"]) self.cover = item_data["cover"]["large"] self.duration = item_data["stream_time"] self.duration_seconds = int(item_data["stream_length"]) if not re.match(r"^\d{2}:\d{2}:\d{2}(?:\.\d+)?", self.duration): self.duration = "0:" + self.duration # Add hour part self.mimetype = "audio/mpeg" self.item = None
def __init__(self, store, id, parent_id, file, title, duration, size, mimetype): BackendItem.__init__(self) self.store = store self.id = f'video.{int(id):d}' self.parent_id = parent_id self.path = str(file) duration = str(duration).strip() duration = duration.split('.')[0] if len(duration) == 0: duration = 0 seconds = int(duration) hours = seconds / 3600 seconds = seconds - hours * 3600 minutes = seconds / 60 seconds = seconds - minutes * 60 self.duration = f'{hours:d}:{minutes:02d}:{seconds:02d}' self.title = str(title) self.cover = None self.mimetype = str(mimetype) self.size = int(size) self.url = self.store.urlbase + str(self.id)
def __init__(self, store, id, parent_id, file, title, duration, \ size, mimetype): BackendItem.__init__(self) self.store = store self.id = 'video.%d' % int(id) self.parent_id = parent_id self.path = unicode(file) duration = str(duration).strip() duration = duration.split('.')[0] if len(duration) == 0: duration = 0 seconds = int(duration) hours = seconds / 3600 seconds = seconds - hours * 3600 minutes = seconds / 60 seconds = seconds - minutes * 60 self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds) self.title = unicode(title) self.cover = None self.mimetype = str(mimetype) self.size = int(size) self.url = self.store.urlbase + str(self.id)
def __init__(self, store, element): BackendItem.__init__(self) self.store = store self.id = 'video.%d' % int(element.get('id')) self.url = element.find('url').text try: seconds = int(element.find('time').text) hours = seconds / 3600 seconds = seconds - hours * 3600 minutes = seconds / 60 seconds = seconds - minutes * 60 self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds) except: self.duration = 0 self.cover = None self.title = element.find('title').text self.mimetype = None try: self.mimetype = element.find('mime').text except: self.mimetype, _ = mimetypes.guess_type(self.url, strict=False) if self.mimetype == None: self.mimetype = "video/avi" try: self.size = int(element.find('size').text) except: self.size = 0 if self.store.proxy == True: self.location = ProxySong(self.url)
def __init__(self, parent_id, id): BackendItem.__init__(self) # the ids as above self.parent_id = parent_id self.id = id # we never have a different name anyway self.name = 'LOLCats' # but we need to set it to a certain mimetype to explain it, that we # contain 'children'. self.mimetype = 'directory' # As we are updating our data periodically, we increase this value so # that our clients can check easier if something has changed since their # last request. self.update_id = 0 # that is where we hold the children self.children = [] # and we need to give a DIDLLite again. This time we want to be # understood as 'Container'. self.item = DIDLLite.Container(id, parent_id, self.name) self.item.childCount = None # will be set as soon as we have images
def __init__(self, id, parent_id, name, store=None, children_callback=None, container_class=DIDLLite.Container, play_container=False): BackendItem.__init__(self) self.id = id self.parent_id = parent_id self.name = name self.mimetype = 'directory' self.container_class = container_class self.update_id = 0 if children_callback != None: self.children = children_callback else: self.children = [] self.childCount = None self.store = store self.play_container = play_container if self.store != None: self.get_url = lambda: self.store.urlbase + str(self.id)
def __init__(self, store, id, parent_id, file, title, date, duration, mimetype): BackendItem.__init__(self) self.store = store self.id = 'recording.%s' % id self.parent_id = parent_id self.real_id = id path = str(file) # make sure path is an absolute local path (and not an URL) if path.startswith("file://"): path = path[7:] self.location = FilePath(path) self.title = str(title) self.mimetype = str(mimetype) self.date = datetime.fromtimestamp(int(date)) self.duration = int(duration) try: self.size = self.location.getsize() except Exception as msg: self.size = 0 self.bitrate = 0 self.url = self.store.urlbase + str(self.id)
def __init__( self, id, parent_id, name, store=None, children_callback=None, container_class=DIDLLite.Container, ): BackendItem.__init__(self) self.id = id self.parent_id = parent_id self.name = name self.mimetype = 'directory' self.item = container_class(id, parent_id, self.name) self.item.childCount = 0 self.update_id = 0 if children_callback is not None: self.children = children_callback else: self.children = util.OrderedDict() self.item.childCount = None # self.get_child_count() if store is not None: self.get_url = lambda: store.urlbase + str(self.id)
def __init__(self, store, id, name): BackendItem.__init__(self) self.store = store self.id = 'artist.%d' % int(id) self.name = name self.children = {} self.sorted_children = None
def __init__(self, store, parent, id, title, enclosure): BackendItem.__init__(self) self.store = store self.parent = parent self.external_id = id self.name = title self.location = RedirectingReverseProxyUriResource( enclosure.url.encode('latin-1')) # doing this because some (Fraunhofer Podcast) feeds say there mime type is audio/x-mpeg # which at least my XBOX doesn't like ext = enclosure.url.rsplit('.', 1)[0] if ext in MIME_TYPES_EXTENTION_MAPPING: mime_type = MIME_TYPES_EXTENTION_MAPPING[ext] else: mime_type = enclosure.type if (enclosure.type.startswith('audio')): self.item = DIDLLite.AudioItem(id, parent, self.name) elif (enclosure.type.startswith('video')): self.item = DIDLLite.VideoItem(id, parent, self.name) elif (enclosure.type.startswith('image')): self.item = DIDLLite.ImageItem(id, parent, self.name) res = DIDLLite.Resource("%s%d" % (store.urlbase, id), 'http-get:*:%s:*' % mime_type) self.item.res.append(res)
def __init__(self, parent_id, id, title, url): BackendItem.__init__(self) self.parentid = parent_id # used to be able to 'go back' self.update_id = 0 self.id = id # each item has its own and unique id self.location = url # the url of the picture self.name = title # the title of the picture. Inside # coherence this is called 'name' # Item.item is a special thing. This is used to explain the client what # kind of data this is. For e.g. A VideoItem or a MusicTrack. In our # case, we have an image. self.item = DIDLLite.ImageItem(id, parent_id, self.name) # each Item.item has to have one or more Resource objects # these hold detailed information about the media data # and can represent variants of it (different sizes, transcoded formats) res = DIDLLite.Resource(self.location, 'http-get:*:image/jpeg:*') res.size = None # FIXME: we should have a size here # and a resolution entry would be nice too self.item.res.append(res)
def __init__(self, store, id, parent_id, file, title, date, duration, mimetype): BackendItem.__init__(self) self.store = store self.id = 'recording.%s' % id self.parent_id = parent_id self.real_id = id path = unicode(file) # make sure path is an absolute local path (and not an URL) if path.startswith("file://"): path = path[7:] self.location = FilePath(path) self.title = unicode(title) self.mimetype = str(mimetype) self.date = datetime.fromtimestamp(int(date)) self.duration = int(duration) try: self.size = self.location.getsize() except Exception, msg: self.size = 0
def __init__(self, store, element): BackendItem.__init__(self) self.store = store self.id = f'video.{int(element.get("id")):d}' self.url = element.find('url').text try: seconds = int(element.find('time').text) hours = seconds / 3600 seconds = seconds - hours * 3600 minutes = seconds / 60 seconds = seconds - minutes * 60 self.duration = f'{hours:d}:{minutes:02d}:{seconds:02d}' except Exception: self.duration = 0 self.cover = None self.title = element.find('title').text self.mimetype = None try: self.mimetype = element.find('mime').text except Exception: self.mimetype, _ = mimetypes.guess_type(self.url, strict=False) if self.mimetype is None: self.mimetype = 'video/avi' try: self.size = int(element.find('size').text) except Exception: self.size = 0 if self.store.proxy: self.location = ProxySong(self.url)
def __init__(self, object_id, parent, path, mimetype, urlbase, UPnPClass, update=False, store=None): BackendItem.__init__(self) self.id = object_id if mimetype == 'root': self.update_id = 0 if mimetype == 'item' and path is None: path = os.path.join(parent.get_realpath(), str(self.id)) self.location = path self.debug("location %s", self.location) self.mimetype = mimetype if urlbase[-1] != '/': urlbase += '/' self.url = urlbase + str(self.id) if parent is None: parent_id = -1 else: parent_id = parent.get_id() self.item = UPnPClass(object_id, parent_id, self.get_name()) if isinstance(self.item, Container): self.item.childCount = 0 self.children = [] self.store = store
def __init__( self, store, id, parent_id, file, title, album, date, width, height, size, mimetype, ): BackendItem.__init__(self) self.store = store self.id = f'image.{int(id):d}' self.parent_id = parent_id self.path = str(file) self.title = str(title) self.album = str(album.strip()) self.mimetype = str(mimetype) self.size = int(size) self.url = self.store.urlbase + str(self.id)
def __init__(self, external_id, title, url, mimetype, entry, store): BackendItem.__init__(self) self.external_id = external_id self.name = title self.duration = None self.size = None self.mimetype = mimetype self.description = None self.date = None self.item = None self.youtube_entry = entry self.store = store def extractDataURL(url, quality): if quality == 'hd': format = '22' else: format = '18' kwargs = { 'usenetrc': False, 'quiet': True, 'forceurl': True, 'forcetitle': False, 'simulate': True, 'format': format, 'outtmpl': '%(id)s.%(ext)s', 'ignoreerrors': True, 'ratelimit': None, } if len(self.store.login) > 0: kwargs['username'] = self.store.login kwargs['password'] = self.store.password fd = FileDownloader(kwargs) youtube_ie = YoutubeIE() fd.add_info_extractor(YoutubePlaylistIE(youtube_ie)) fd.add_info_extractor(MetacafeIE(youtube_ie)) fd.add_info_extractor(youtube_ie) deferred = fd.get_real_urls([url]) return deferred # self.location = VideoProxy( # url, self.external_id, # store.proxy_mode, # store.cache_directory, store.cache_maxsize, store.buffer_size, # extractDataURL, quality=self.store.quality) self.location = TestVideoProxy( url, self.external_id, store.proxy_mode, store.cache_directory, store.cache_maxsize, store.buffer_size, extractDataURL, quality=self.store.quality, )
def __init__(self, title, stream_url, mimetype): BackendItem.__init__(self) self.name = title self.stream_url = stream_url self.mimetype = mimetype self.url = stream_url self.item = None
def __init__(self, *args, **kwargs): BackendItem.__init__(self, *args, **kwargs) self._row = args[0] self._store = args[1] self._db = self._store.db self.title = self._row.Name if self.title: self.title = self.title.encode("utf-8")
def __init__(self, id, obj, parent, mimetype, urlbase, UPnPClass, update=False): BackendItem.__init__(self) self.id = id self.name = obj.get('title') # .encode('utf-8') if self.name == None: self.name = obj.get('name') if self.name == None: self.name = id self.mimetype = mimetype self.gallery2_id = obj.get('gallery2_id') self.parent = parent if parent: parent.add_child(self, update=update) if parent == None: parent_id = -1 else: parent_id = parent.get_id() self.item = UPnPClass(id, parent_id, self.name) if isinstance(self.item, Container): self.item.childCount = 0 self.child_count = 0 self.children = None if (len(urlbase) and urlbase[-1] != '/'): urlbase += '/' if parent == None: self.gallery2_url = None self.url = urlbase + str(self.id) elif self.mimetype == 'directory': #self.gallery2_url = parent.store.get_url_for_album(self.gallery2_id) self.url = urlbase + str(self.id) else: self.gallery2_url = parent.store.get_url_for_image( self.gallery2_id) self.url = urlbase + str(self.id) self.location = ProxyGallery2Image(self.gallery2_url) if self.mimetype == 'directory': self.update_id = 0 else: res = Resource(self.gallery2_url, 'http-get:*:%s:*' % self.mimetype) res.size = None self.item.res.append(res)
def __init__(self, store, id, title, artist): BackendItem.__init__(self) self.store = store self.id = f'album.{int(id):d}' self.name = str(title) self.artist = str(artist) self.cover = None self.children = {} self.sorted_children = None
def __init__(self, title, url, status=None, viewers=0, created_at=None, preview_url=None): BackendItem.__init__(self) self.name = title self.status = status self.mimetype = MPEG_MIME self.created_at = created_at self.preview_url = preview_url self.viewers = viewers self.location = LiveStreamerProxyResource(url, 'best')
def __init__(self, store, id, title, artist): BackendItem.__init__(self) self.store = store self.id = 'album.%d' % int(id) self.name = unicode(title) self.artist = unicode(artist) self.cover = None self.children = {} self.sorted_children = None
def __init__(self, parent_id, id, title): BackendItem.__init__(self) self.id = id self.parent_id = parent_id self.name = title self.mimetype = 'directory' self.item = DIDLLite.Container(self.id, self.parent_id, self.name) self.children = []
def __init__(self, *args, **kwargs): BackendItem.__init__(self, *args, **kwargs) self._row = args[0] self._db = args[1] self.itemID = self._row.TrackID self.title = self._row.Title self.track_nr = self._row.TrackNumber self.location = self._row.Uri self.playlist = kwargs.get("playlist")
def __init__(self, title, stream_url, mimetype, **kwargs): BackendItem.__init__(self) self.name = title self.stream_url = stream_url self.mimetype = mimetype self.url = stream_url self.item = kwargs.get('item', None) self.parent = kwargs.get('parent', None) self.update_id = kwargs.get('update_id', 0)
def __init__(self, station_id, title, stream_url, mimetype): BackendItem.__init__(self) self.station_id = station_id self.name = title self.mimetype = mimetype self.stream_url = stream_url self.location = PlaylistStreamProxy(self.stream_url) self.item = None
def __init__(self, *args, **kwargs): BackendItem.__init__(self, *args, **kwargs) self._row = args[0] self._db = args[1] self._local_music_library_id = args[2] self.musicbrainz_id = self._row.MusicBrainzID self.itemID = self._row.ArtistID self.name = self._row.Name or '' if self.name: self.name = self.name.encode("utf-8")
def __init__(self, device_name="/dev/cdrom", track_number=1, artist="Unknown", title="Unknown"): BackendItem.__init__(self) self.device_name = device_name self.track_number = track_number self.artist = artist self.title = title self.mimetype = TRACK_MIMETYPE self.fourth_field = TRACK_FOURTH_FIELD self.item = None self.pipeline = PLAY_TRACK_GST_PIPELINE % (self.device_name, self.track_number) self.location = GStreamerPipeline(self.pipeline, self.mimetype)
def __init__(self, outline): BackendItem.__init__(self) self.preset_id = outline.get('preset_id') self.name = outline.get('text') self.mimetype = DEFAULT_MIMETYPE self.stream_url = outline.get('URL') self.image = outline.get('image') #self.location = PlaylistStreamProxy(self.stream_url) #self.url = self.stream_url self.item = None
def __init__(self, store, id, parent_id, name, url, network, mimetype): BackendItem.__init__(self) self.store = store self.id = f'channel.{id}' self.parent_id = parent_id self.real_id = id self.name = str(name) self.network = str(network) self.stream_url = url self.mimetype = str(mimetype)
def __init__(self, *args, **kwargs): BackendItem.__init__(self, *args, **kwargs) self._row = args[0] self._db = args[1] self.artist = args[2] self.itemID = self._row.AlbumID self.title = self._row.Title self.cover = get_cover_path(self.artist.name, self.title) if self.title: self.title = self.title.encode("utf-8") self.musicbrainz_id = self._row.MusicBrainzID self.cd_count = 1
def __init__(self, store, element): BackendItem.__init__(self) self.store = store self.ampache_id = element.get('id') self.id = 'album.%d' % int(element.get('id')) self.title = element.find('name').text self.artist = element.find('artist').text self.tracks = int(element.find('tracks').text) try: self.cover = element.find('art').text except: self.cover = None
def __init__(self, id, parent_id, name, store=None, \ children_callback=None): BackendItem.__init__(self) self.id = id self.parent_id = parent_id self.name = name self.mimetype = 'directory' self.update_id = 0 self.children = [] self.item = DIDLLite.Container(id, parent_id, self.name) self.item.childCount = None # self.get_child_count()
def __init__(self, parent_id, id, title, url): BackendItem.__init__(self) self.parent_id = parent_id self.id = id self.location = url self.name = title self.duration = None self.size = None self.mimetype = 'audio/mpeg' self.description = None self.item = None
def __init__(self, parent_id, id, name): BackendItem.__init__(self) self.parent_id = parent_id self.id = id self.name = name self.mimetype = "directory" self.update_id = 0 self.children = [] self.item = DIDLLite.Container(id, parent_id, self.name) self.item.childCount = None # will be set as soon as we have images
def __init__(self, parent_id, urlbase, id=None, name=None, cover=None, url=None): BackendItem.__init__(self) self.parentid = parent_id self.id = id self.name = name self.cover = cover if(len(urlbase) and urlbase[-1] != '/'): urlbase += '/' self.url = urlbase + str(self.id) self.location = AppleTrailerProxy(url) self.item = DIDLLite.VideoItem(id, parent_id, self.name) self.item.albumArtURI = self.cover
def __init__(self, external_id, title, url, mimetype, entry, store): BackendItem.__init__(self) self.external_id = external_id self.name = title self.duration = None self.size = None self.mimetype = mimetype self.description = None self.date = None self.item = None self.youtube_entry = entry self.store = store def extractDataURL(url, quality): if (quality == 'hd'): format = '22' else: format = '18' kwargs = { 'usenetrc': False, 'quiet': True, 'forceurl': True, 'forcetitle': False, 'simulate': True, 'format': format, 'outtmpl': u'%(id)s.%(ext)s', 'ignoreerrors': True, 'ratelimit': None, } if len(self.store.login) > 0: kwargs['username'] = self.store.login kwargs['password'] = self.store.password fd = FileDownloader(kwargs) youtube_ie = YoutubeIE() fd.add_info_extractor(YoutubePlaylistIE(youtube_ie)) fd.add_info_extractor(MetacafeIE(youtube_ie)) fd.add_info_extractor(youtube_ie) deferred = fd.get_real_urls([url]) return deferred #self.location = VideoProxy(url, self.external_id, # store.proxy_mode, # store.cache_directory, store.cache_maxsize, store.buffer_size, # extractDataURL, quality=self.store.quality) self.location = TestVideoProxy(url, self.external_id, store.proxy_mode, store.cache_directory, store.cache_maxsize, store.buffer_size, extractDataURL, quality=self.store.quality)
def __init__(self, movie, store, title=None, url=None): BackendItem.__init__(self) self.movie_id = 'UNK' if movie.find('./id') is not None: self.movie_id = movie.find('./id').text self.title = movie.find('./title').text self.baseFilename = movie.find('./baseFilename').text self.plot = movie.find('./plot').text self.outline = movie.find('./outline').text self.posterFilename = movie.find('./posterFile').text self.thumbnailFilename = movie.find('./thumbnail').text self.rating = movie.find('./rating').text self.director = movie.find('./director').text self.genres = movie.findall('./genres/genre') self.actors = movie.findall('./cast/actor') self.year = movie.find('year').text self.audioChannels = movie.find('audioChannels').text self.resolution = movie.find('resolution').text self.language = movie.find('language').text self.season = movie.find('season').text if title is not None: self.upnp_title = title else: self.upnp_title = self.title if url is not None: self.movie_url = url else: self.movie_url = movie.find('./files/file/fileURL').text self.posterURL = "%s/%s" % (store.jukebox_url, self.posterFilename) self.thumbnailURL = "%s/%s" % (store.jukebox_url, self.thumbnailFilename) #print self.movie_id, self.title, self.url, self.posterURL self.str_genres = [] for genre in self.genres: self.str_genres.append(genre.text) self.str_actors = [] for actor in self.actors: self.str_actors.append(actor.text) url_mimetype, _ = mimetypes.guess_type(self.movie_url, strict=False) if url_mimetype is None: url_mimetype = "video" self.name = self.title self.duration = None self.size = None self.mimetype = url_mimetype self.item = None
def __init__(self, id, store, parent_id, title): BackendItem.__init__(self) self.url = store.urlbase + str(id) self.parent_id = parent_id self.id = id self.name = title self.mimetype = 'directory' self.update_id = 0 self.children = [] self.item = DIDLLite.Container(self.id, self.parent_id, self.name) self.item.childCount = 0 self.sorted = False
def __init__(self, store, id, parent_id, name, url, network, mimetype): BackendItem.__init__(self) self.store = store self.id = 'channel.%s' % id self.parent_id = parent_id self.real_id = id self.name = unicode(name) self.network = unicode(network) self.stream_url = url self.mimetype = str(mimetype)
def __init__(self, parent_id, store, id, name, author, author_image): BackendItem.__init__(self) self.parent_id = parent_id self.update_id = 0 self.store = store self.id = id self.name = name self.author = author self.author_image = author_image self.tracks = [] self.mimetype = "directory"
def __init__(self, id, parent_id, name, children_callback=None, store=None, play_container=False): BackendItem.__init__(self) self.id = id self.parent_id = parent_id self.name = name self.mimetype = 'directory' self.store = store self.play_container = play_container self.update_id = 0 if children_callback != None: self.children = children_callback else: self.children = []
def __init__(self, store, id, obj, parent): BackendItem.__init__(self) self.parent = parent self.id = id self.name = obj.get('name') self.mimetype = obj.get('mimetype') self.description = None self.date = None self.item = None self.duration = None self.store = store self.url = self.store.urlbase + str(self.id) self.stream_url = obj.get('url') self.location = ProxyStream(self.stream_url)
def __init__(self, id, obj, parent, mimetype, urlbase, UPnPClass, update=False): BackendItem.__init__(self) self.id = id self.name = obj.get('title') # .encode('utf-8') if self.name == None: self.name = obj.get('name') if self.name == None: self.name = id self.mimetype = mimetype self.gallery2_id = obj.get('gallery2_id') self.parent = parent if parent: parent.add_child(self, update=update) if parent == None: parent_id = -1 else: parent_id = parent.get_id() self.item = UPnPClass(id, parent_id, self.name) if isinstance(self.item, Container): self.item.childCount = 0 self.child_count = 0 self.children = None if(len(urlbase) and urlbase[-1] != '/'): urlbase += '/' if parent == None: self.gallery2_url = None self.url = urlbase + str(self.id) elif self.mimetype == 'directory': #self.gallery2_url = parent.store.get_url_for_album(self.gallery2_id) self.url = urlbase + str(self.id) else: self.gallery2_url = parent.store.get_url_for_image(self.gallery2_id) self.url = urlbase + str(self.id) self.location = ProxyGallery2Image(self.gallery2_url) if self.mimetype == 'directory': self.update_id = 0 else: res = Resource(self.gallery2_url, 'http-get:*:%s:*' % self.mimetype) res.size = None self.item.res.append(res)
def __init__(self, parent_id, id, title=None, url=None, duration=None, size=None): BackendItem.__init__(self) self.parentid = parent_id self.update_id = 0 self.id = id self.location = url self.name = title self.item = DIDLLite.VideoItem(id, parent_id, self.name) res = DIDLLite.Resource(self.location, 'http-get:*:video/mp4:*') # FIXME should be video/x-m4a res.size = size res.duration = duration self.item.res.append(res)
def __init__(self, parent_id, store, id, title, artist_id, artist, albumArtURI): BackendItem.__init__(self) self.parent_id = parent_id self.update_id = 0 self.id = id self.title = title self.artist = artist self.artist_id = artist_id self.store = store self.albumArtURI = albumArtURI self.name = self.title self.tracks = {} self.mimetype = "directory"
def __init__(self, id, parent_id, name, store=None, children_callback=None, container_class=DIDLLite.Container): BackendItem.__init__(self) self.id = id self.parent_id = parent_id self.name = name self.mimetype = 'directory' self.item = container_class(id, parent_id, self.name) self.item.childCount = 0 self.update_id = 0 if children_callback != None: self.children = children_callback else: self.children = util.OrderedDict() if store != None: self.get_url = lambda: store.urlbase + str(self.id)