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()
