def func(*args, **kwargs): request_args = [] for idx, arg in enumerate(cmd_args): try: value = args[idx + 1] except IndexError: if arg["req"] is True: raise DeejaydError("argument %s is required" % arg["name"]) # perhaps argument is available in key/value arguments try: value = kwargs[arg["name"]] except KeyError: continue # TODO verify arguments if arg["type"] == "filter" and value is not None: try: value = value.to_json() except: raise DeejaydError("arg %s is not a valid " "filter" % arg["name"]) request_args.append(value) self = args[0] cmd = prefix == "" and cmd_name or prefix + "." + cmd_name request = JSONRPCRequest(cmd, request_args) try: return self._send_command(request) except AttributeError: # we are in a submodule return self.core._send_command(request)
def impl(self, source_name, *args, **kwargs): if source_name not in self.wb_sources: raise DeejaydError( _("Webradio source %s not " "supported") % source_name) source = self.wb_sources[source_name] if editable and not IEditWebradioSource.providedBy(source): raise DeejaydError(_("You can not edit this webradio source")) res = func(self, source, *args, **kwargs) return res
def add_webradio(self, source, name, urls, cat=None): provided_urls = [] for url in urls: if url.lower().startswith("http://") or \ url.lower().startswith("https://"): try: if url.lower().endswith(".pls"): provided_urls.extend(get_uris_from_pls(url)) elif url.lower().endswith(".m3u"): provided_urls.extend(get_uris_from_m3u(url)) else: provided_urls.append(url) except IOError: log.err(_("Could not parse %s") % url) pass needed_urls = [] for url in provided_urls: try: protocol = url.split(':')[0] if protocol not in ( 'http', 'https', 'rtsp', ): raise ValueError except ValueError: log.err( _("Discarding %s : webradio protocol not supported.") % url) else: if url not in needed_urls: needed_urls.append(url) if len(needed_urls) < 1: raise DeejaydError( _("Given urls %s is not " "supported") % ",".join(urls)) cats = cat is not None and [cat] or [] webradio = Session.query(Webradio)\ .filter(Webradio.source == source)\ .filter(Webradio.name == name)\ .one_or_none() if webradio is not None: raise DeejaydError(_("Webradio %s already exists") % name) webradio = Webradio(source=source, name=name) Session.add(webradio) for c in cats: webradio.categories.append(Session.query(WebradioCategory).get(c)) for url in needed_urls: webradio.entries.append(WebradioEntry(url=url))
def parse_deejayd_answer(answer): if answer["error"] is not None: # an error is returned error = "Deejayd Server Error - %s - %s"\ % (answer["error"]["code"], answer["error"]["message"]) raise DeejaydError(error) result = answer["result"]["answer"] r_type = answer["result"]["type"] if r_type == "filterList": try: result = [load_mediafilter(f) for f in result] except Fault: raise DeejaydError("Unable to parse filter in answer") return result
def set_subscription(self, signal_name, value): if signal_name not in SIGNALS: raise DeejaydError(_("Signal %s does not exist") % signal_name) if value is False: self.factory.set_not_signaled(self, signal_name) elif value is True: self.factory.set_signaled(self, signal_name)
def load_medias(self, media_ids, queue=True): medias = self._library.get_file_withids(media_ids) if len(media_ids) != len(medias): raise DeejaydError( _("Some medias has not been " "found in the library.")) self._playlist.load(medias, queue) self.dispatch_signame(self.source_signal)
def create(self, name, p_type): if name == "": raise DeejaydError(_("Set a playlist name")) if p_type not in ("static", "magic"): raise DeejaydError(_("playlist type has to be 'static' or 'magic'")) pls = Session.query(MediaList)\ .filter(MediaList.name == name)\ .one_or_none() if pls is not None: raise DeejaydError(_("This playlist already exists")) pl_cls = p_type == "static" and StaticMediaList or MagicMediaList pls = pl_cls(name=name) Session.add(pls) Session.commit() self.dispatch_signame('recpls.listupdate') return {"pl_id": pls.id, "name": name, "type": p_type}
def set_option(self, name, value): if name == "playorder": try: self._playorder = orders[value] except KeyError: raise DeejaydError( _("Unable to set %s order, not " "supported") % value) else: self.state["playorder"] = value elif name == "repeat" and self.has_repeat: if not isinstance(value, bool): raise DeejaydError(_("Option value has to be a boolean")) self._playlist.repeat = value self.state["repeat"] = value else: raise DeejaydError(_("Option %s not supported")) self.dispatch_signame(self.source_signal)
def get_content(self, pl_id, first=0, length=None): magic_or_static = with_polymorphic(MediaList, "*") pls = Session.query(magic_or_static)\ .filter(MediaList.id == pl_id)\ .one_or_none() if pls is None: raise DeejaydError(_("Playlist with id %s does not exist")) return [m.to_json() for m in pls.get_medias(Session, first, length)]
def save_state(self): if self.state is None: raise DeejaydError( _("You try to save a state " "which has not been loaded !")) st_name = "%s_state" % self.state_name s = Session.query(State) \ .filter(State.name == st_name) \ .one() s.state = self.state
def set_rating(self, ft, rating): if int(rating) not in list(range(0, 5)): raise DeejaydError(_("Bad rating value")) q = Session.query(self.OBJECT_CLASS) if ft is not None: q = q.filter(ft.get_filter(self.OBJECT_CLASS)) for m in q.all(): m.rating = rating Session.commit()
def get_dir_content(self, f_name=""): f_path = os.path.join(self.root_path, f_name).rstrip("/") folder = self._get_folder(f_path) if folder is not None: return folder.to_json(subfolders=True, medias=True) elif f_name == "": return {"path": "", "files": [], "directories": []} else: err = _("Unable to find '%s' folder in library") % f_name raise DeejaydError(err)
def add_category(self, source, cat_name): category = Session.query(WebradioCategory)\ .filter(WebradioCategory.source == source)\ .filter(WebradioCategory.name == cat_name)\ .one_or_none() if category is not None: raise DeejaydError(_("Category %s already exists") % cat_name) category = WebradioCategory(source=source, name=cat_name) Session.add(category) return category.to_json()
def get_uris_from_pls(URL): uris = [] lines = get_playlist_file_lines(URL) if not lines[0].startswith("[playlist]"): raise DeejaydError(_("Playlist has a wrong format")) for line in lines: if line.lower().startswith("file") and line.find("=") != -1: uris.append(line[line.find("=") + 1:].strip()) return uris
def magic_set_property(self, pls, k, v): p_list = [ "use-or-filter", "use-limit", "limit-value", "limit-sort-value", "limit-sort-direction" ] if k not in p_list: raise DeejaydError(_("Property %s does not exist " "for magic playlist") % k) setattr(pls, k.replace("-", "_"), v) return True
def _build_answer(self, msg): try: msg = loads_response(msg) except Fault as f: raise DeejaydError("JSONRPC error - %s - %s" % (f.code, f.message)) if msg["id"] is None: # it is a notification result = msg["result"]["answer"] type = msg["result"]["type"] if type == 'signal': signal = {"name": result["name"], "attrs": result["attrs"]} return self._dispatch_signal(signal) return None return msg
def search(self, f=None, ords=[], limit=None): ft = And() if f is not None: ft.combine(f) try: db_filter = ft.get_filter(self.OBJECT_CLASS) except AttributeError as ex: raise DeejaydError(str(ex)) ords = ords or self.DEFAULT_SORT medias = Session.query(self.OBJECT_CLASS) \ .filter(db_filter) \ .order_by(ords) \ .all() return [m.to_json() for m in medias]
def load_mediafilter(json_filter): try: name = json_filter["id"] f_type = json_filter["type"] if f_type == "basic": filter_class = BASIC_FILTERS[name] ft = filter_class(json_filter["value"]["tag"], json_filter["value"]["pattern"]) elif f_type == "complex": ft = COMPLEX_FILTERS[name]() for f in json_filter["value"]: ft.combine(load_mediafilter(f)) else: raise TypeError return ft except Exception as err: raise DeejaydError( _("%s is not a json encoded " "filter: %s") % (json_filter, err))
def load_playlist_func(self, pl_id, *__args, **__kw): if pls_type == "static": pls = Session.query(StaticMediaList).get(pl_id) elif pls_type == "magic": all_ft = with_polymorphic(Filter, "*", flat=True) pls = Session.query(MagicMediaList)\ .options(subqueryload( MagicMediaList.filters.of_type(all_ft)) )\ .filter(MagicMediaList.id == pl_id)\ .one() if pls is None: raise DeejaydError(_("Playlist %s not found") % str(pl_id)) rs = func(self, pls, *__args, **__kw) if rs is True: Session.commit() self.dispatch_signame('recpls.update', pl_id=pl_id) return None return rs
def get_webradios(self, cat_id=None, first=0, length=None): if cat_id is None: query = Session.query(Webradio)\ .join(WebradioSource)\ .filter(WebradioSource.name == self.NAME)\ .offset(first) if length is not None: query = query.limit(length) webradios = query.all() else: category = Session.query(WebradioCategory).get(cat_id) if category is None: raise DeejaydError( _("Category with id %s " "is not found") % cat_id) if length is not None: stop = min(first + int(length), len(category.webradios)) else: stop = len(category.webradios) first = min(first, stop) webradios = category.webradios[first:stop] return [w.to_json() for w in webradios]
def __init__(self, path): super(BaseLibrary, self).__init__() # get root path for this library path = os.path.abspath(path).rstrip("/") self.root_path = path # test library path if not os.path.isdir(self.root_path): msg = _("Unable to find '%s' folder in library") % self.root_path raise DeejaydError(msg) library = Session.query(Library) \ .filter(Library.name == self.TYPE) \ .one_or_none() if library is None: library = Library(name=self.TYPE, path=self.root_path) Session.add(library) Session.commit() self.library_id = library.id self.updating_state = {"id": 0, "running": False, "error": None} self.parser = self.PARSER(self) self.watcher = None self.load_state()
def wait_for_answer(self): self.answer_received_evt.wait() if self.error is not None: raise DeejaydError(self.error) return self.answer
def get_file(self, file_path): abs_path = os.path.join(self.root_path, file_path) media = self._get_file_with_path(abs_path) if media is None: raise DeejaydError(_("file %s is not found in the db") % file_path) return media
def get_source(self, s): if s not in self.sources: raise DeejaydError(_("Source %s not found") % s) return self.sources[s]
def get_webradios(self, cat_id=None, first=0, length=None): if self.state["last_modified"] == -1: raise DeejaydError("Unable to parse icecast webradio list") return super(IceCastSource, self).get_webradios(cat_id, first, length)
def __reload_list(self): log.msg(_("Start to reload icecast webradio source")) url = DeejaydConfig().get("webradio", "icecast_url") try: page_handle = urllib.request.urlopen(url, timeout=TIMEOUT) xml_page = page_handle.read() except Exception: raise DeejaydError(_("Unable to connect to icecast website")) # try to parse result try: root = ET.fromstring(xml_page) except ET.XMLSyntaxError: raise DeejaydError(_("Unable to parse icecast webradio list")) except Exception: raise DeejaydError( _("Unable to read result from icecast " "webradio list")) finally: page_handle.close() DatabaseLock.acquire() session = Session() source = session.query(WebradioSource)\ .filter(WebradioSource.name == self.NAME)\ .one() # delete old entries from the database session.query(Webradio)\ .filter(Webradio.source_id == source.id)\ .delete(synchronize_session='fetch') session.query(WebradioCategory)\ .filter(WebradioCategory.source_id == source.id)\ .delete(synchronize_session='fetch') categories = {} webradios = {} for station in root: try: server_type = station.find("server_type").text listen_url = station.find("listen_url").text genres = station.find("genre").text name = station.find("server_name").text except TypeError: continue if server_type.startswith("audio") or \ (server_type == "application/ogg" and not listen_url.endswith("ogv")): if name not in webradios: genres = genres.split(" ") webradios[name] = Webradio(source=source, name=name) for genre in genres: if len(genre) <= 2 or genre.startswith("."): continue genre = genre.capitalize() if genre not in categories: categories[genre] = WebradioCategory(name=genre, source=source) webradios[name].categories.append(categories[genre]) session.add(webradios[name]) webradios[name].entries.append(WebradioEntry(url=listen_url)) log.debug('Added icecast webradio %s' % name) session.commit() Session.remove() DatabaseLock.release() log.msg(_("Finish to reload icecast webradio source")) return { "wb_count": len(webradios), "cat_count": len(categories), }
def play_webradio(self, w_id): w = Session.query(Webradio).get(w_id) if w is None: raise DeejaydError(_("Webradio with id '%s' is not found") % w_id) self.player.play_webradio(WebradioObject(w))
def set_source(self, s): if s not in self.sources: raise DeejaydError(_("Source %s not found") % s) self.state["active"] = s
def get_categories(self): if self.state["last_modified"] == -1: raise DeejaydError("Unable to parse icecast webradio list") return super(IceCastSource, self).get_categories()