def cmd_current(self, q):
queue = yield self.queue_cmd("queue",
{"parameters": self.pretty_params})
if len(queue) == 0:
raise service.Return("(Nothing)")
result = self.pretty(queue[0])
raise service.Return(result)
def set_state(self, name, relay, new_state):
name = name.upper()
if name in self.devices:
self.devices[name].set(relay, state=new_state)
self.devices[name].flush()
raise service.Return(True)
raise service.Return(False)
def cmd_queue(self, q):
queue = yield self.queue_cmd("queue",
{"parameters": self.pretty_params})
if len(queue) == 0:
raise service.Return("Queue is empty.")
result = '\n'.join([
u"{0}. {1}".format(n + 1, self.pretty(mod))
for (n, mod) in enumerate(queue)
])
raise service.Return(result)
def vol_cmd(self, cmd, args={}, assert_success=True):
try:
result = yield service.json_query(self.vol_host, self.vol_port, {
"cmd": cmd,
"args": args
})
except (socket.error, service.TimeoutError):
raise Exception("Error communicating with volume control.")
if assert_success:
raise service.Return(packet.assert_success(result))
raise service.Return(result)
def do(self, message):
message = message.strip()
for (regex, func) in self.nlp_commands:
m = re.match(regex, message, re.I)
if m:
result = yield func(self, message, *m.groups())
raise service.Return(result)
raise Exception("Command not recognized.")
#result = yield self.queue_cmd("queue")
raise service.Return({'message': 'Did ' + message})
def youtube_search(self, q):
if q in self.youtube_cache:
print "cache hit"
raise service.Return(self.youtube_cache[q])
print "cache miss"
http_client = tornado.httpclient.AsyncHTTPClient()
# Return the args dict for the first youtube result for 'match'
youtube_search_url = "https://www.googleapis.com/youtube/v3/search"
search_data = {
"part": "snippet",
"key": self.youtube_api_key,
"order": "relevance",
"safesearch": "none",
"type": "video",
"max-results": 5,
"q": q,
}
search_form_data = urllib.urlencode(search_data)
search_results = yield http_client.fetch(youtube_search_url + "?" +
search_form_data)
search_json = json.loads(search_results.body)
video_ids = [v["id"]["videoId"] for v in search_json["items"]]
youtube_video_url = "https://www.googleapis.com/youtube/v3/videos"
video_data = {
"part": "contentDetails,snippet,statistics",
"key": self.youtube_api_key,
"id": ",".join(video_ids),
}
video_form_data = urllib.urlencode(video_data)
video_results = yield http_client.fetch(youtube_video_url + "?" +
video_form_data)
video_json = json.loads(video_results.body)
output = []
for yi in video_json['items']:
sr = {
"video_id": yi["id"],
"url": "http://www.youtube.com/watch?v={0}".format(yi["id"]),
"title": yi["snippet"]["title"],
"thumbnail": yi["snippet"]["thumbnails"]["default"]["url"],
"publish_time": yi["snippet"]["publishedAt"],
"views": yi["statistics"]["viewCount"],
"duration":
self.parse_duration(yi["contentDetails"]["duration"]),
}
output.append(sr)
self.youtube_cache[q] = output
raise service.Return(output)
def cmd_bug(self, q, text):
bug_url = "https://api.github.com/repos/zbanks/musicazoo/issues"
suffix = "\n\nSubmitted via NLP service."
bug_data = json.dumps({'title': text, 'body': text + suffix})
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
try:
password_mgr.add_password(None, bug_url, settings.github_login[0],
settings.github_login[1])
except AttributeError:
raise service.Return(
u"No github account configured in settings.json")
handler = urllib2.HTTPBasicAuthHandler(password_mgr)
#TODO request(bug_url, bug_data, auth=(musicazoo-bugs, musicaz00)
raise service.Return(u'Submitted bug: %s - thanks!')
def cmd_rm_bot(self, q):
queue = yield self.queue_cmd("queue",
{"parameters": self.pretty_params})
if len(queue) == 0:
raise Exception("Queue is empty!")
mod = queue[-1]
yield self.queue_cmd("rm", {"uids": [mod['uid']]})
raise service.Return(u"Removed {0}".format(self.pretty(mod)))
def get_vol(self):
if alsaaudio:
v = self.mixer.getvolume()[0]
elif osax:
v = self.mixer.get_volume_settings()[osax.k.output_volume]
else:
v = 0
raise service.Return({'vol': computer_to_human(v)})
def wildcard_suggest(self, text):
text = text.strip()
results = []
if text.startswith("http:"):
rs = yield self.url_suggest(text)
results.extend(rs)
yr = yield self.youtube_suggest(text)
results.extend(yr)
raise service.Return(results)
def url_suggest(self, url):
#TODO
results = [{
"title": url,
"action": url,
"help": "",
"match": len(url)
}]
yield service.Return(results)
def set_vol(self, vol):
v = human_to_computer(vol)
if alsaaudio:
self.mixer.setvolume(v)
elif osax:
self.mixer.set_volume(output_volume=v)
else:
print "Setting fake volume: ", v
raise service.Return({})
def cmd_swear(self, q):
# Swear words according to yahoo chat.
# See: http://ridiculousfish.com/blog/posts/YahooChatRooms.html
words = "ahole,aholes,asshole,assholes,asswipe,biatch,bitch,bitches,blo_job,blow_job,b*****b,c********r,c**t,cunts,dickhead,f**k,f****d,f*****g,fuckoff,f***s,handjob,handjobs,m**********r,mother-f****r,motherfuckers,muthafucker,muthafuckers,n***a,niggs,nigger,niggers,pedofile,pedophile,phag,phuc,phuck,phucked,phucker,shat,shit,shits,s******d,shitter,s******g".split(
",")
selection = random.sample(words, 5)
text = " ".join(selection)
yield self.queue_cmd("add", {"type": "text", "args": {"text": text}})
raise service.Return(u'Queued swearing.')
def cmd_yt(self, q, kw):
result = yield self.youtube_search(kw)
if not result or not result[0]:
raise Exception('No Youtube results found.')
url = result[0]["url"]
title = result[0]["title"]
yield self.queue_cmd("add", {"type": "youtube", "args": {"url": url}})
raise service.Return(u'Queued "{0}"'.format(title))
def cmd_list(self, offset=0, count=100):
count = max(min(self.MAX_COUNT, count), 1)
rows = self.db.execute_select("""SELECT
COUNT(mle_qa.pk) AS addcount,
COUNT(mle_mp.pk) AS playcount,
top_item_module.item_pk,
top_item.requeue_command AS requeue_command,
top_item.url AS url,
top_item.description AS description
FROM top_item_module
INNER JOIN top_item
ON top_item.pk = top_item_module.item_pk
LEFT JOIN top_module AS mod_qa
ON top_item_module.module_uuid = mod_qa.uuid
LEFT JOIN top_module AS mod_mp
ON top_item_module.module_uuid = mod_mp.uuid
LEFT JOIN top_module_log_entry AS mle_qa
ON mod_qa.uuid = mle_qa.module_uuid
LEFT JOIN top_module_log_entry AS mle_mp
ON mod_mp.uuid = mle_mp.module_uuid
WHERE (mle_qa.log_type = "queue_add" OR mle_qa.log_type IS NULL)
AND (mle_mp.log_type = "module_play" OR mle_mp.log_type IS NULL)
GROUP BY top_item_module.item_pk
ORDER BY addcount DESC
LIMIT :offset, :count
""",
offset=offset,
count=count)
last_rank = offset + 1
last_plays = None
results = []
for i, row in enumerate(rows):
print row
if row["addcount"] == last_plays:
rank = last_rank
else:
rank = offset + 1 + i
last_rank = rank
last_plays = row["addcount"]
results.append({
'url': row['url'],
'description': row['description'],
'command': row['requeue_command'],
'queue_count': row['addcount'],
'play_count': row['playcount'],
'rank': rank,
})
raise service.Return(results)
def cmd_bump(self, q):
queue = yield self.queue_cmd("queue",
{"parameters": self.pretty_params})
if len(queue) == 0:
raise Exception("Queue is empty!")
if len(queue) == 1:
raise Exception("Only one thing on the queue!")
old_uids = [mod['uid'] for mod in queue]
mod_bot = queue[-1]
new_uids = old_uids[-1:] + old_uids[0:-1]
yield self.queue_cmd("mv", {"uids": [mod['uid']]})
raise service.Return(u"Bumped {0} to the top".format(
self.pretty(mod_bot)))
def cmd_help(self, q):
raise service.Return("""Commands I understand:
help|? - This
vol - Get volume
vol [num] - Set volume
vol up|down - Change volume
stop|stfu|skip|next - Remove the top video
pop|undo|oops - Remove the bottom video
bump - Move the bottom video to the top
q|queue - List the queue
cur|current - Give the current item playing
bug - Submit a bug report
Anything else - Queue Youtube video""")
def suggest(self, message):
stripped_message = message.strip()
suggestions = []
for sc, sc_help in self.suggest_commands:
if sc.startswith(stripped_message):
suggestions.append({
"title": sc,
"action": sc,
"help": sc_help,
"match": len(stripped_message)
})
rs = yield self.wildcard_suggest(message)
suggestions.extend(rs)
raise service.Return({'suggestions': suggestions})
def youtube_suggest(self, q):
videos = yield self.youtube_search(q)
results = []
for v in videos:
results.append({
"title":
u"{0[title]} - [{0[duration][1]}]".format(v),
"action":
v['url'],
"help":
"Play video from YouTube",
"match":
0,
})
raise service.Return(results)
def cmd_set_vol(self, q, vol):
if vol == 'up':
result = yield self.vol_cmd("get_vol")
vol = min(result['vol'] + 5, 100)
elif vol == 'down':
result = yield self.vol_cmd("get_vol")
vol = max(result['vol'] - 5, 0)
else:
vol = int(vol)
if vol > 100:
raise Exception("Volume cannot be greater than 100")
yield self.vol_cmd("set_vol", {"vol": vol})
raise service.Return("Volume set to {0}".format(vol))
def cmd_fortune(self, q):
fortune_args = settings.get("fortune_args", ['-s'])
fortune_text = subprocess.check_output(['/usr/games/fortune'] +
fortune_args)
data = {
'type': 'text',
'args': {
'text': fortune_text,
#'screen_preprocessor': 'none',
'speech_preprocessor': 'pronounce_fortune',
'text2speech': 'google',
'text2screen': 'paragraph',
#'renderer': 'mono_paragraph',
'duration': 5,
}
}
yield self.queue_cmd("add", data)
raise service.Return(u"Queued fortune.")
def cmd_image(self, q, url):
yield self.queue_cmd("set_bg", {"type": "image", "args": {"url": url}})
raise service.Return(u'Queued text.')
def cmd_update(self):
#TODO: this is a temp fix until daemonized properly
rc = self.import_queue_log()
raise service.Return("Updated records")
def youtube_search(self, q):
if q in self.youtube_cache:
print "cache hit"
raise service.Return(self.youtube_cache[q])
print "cache miss"
http_client = tornado.httpclient.AsyncHTTPClient()
# Return the args dict for the first youtube result for 'match'
youtube_search_url = "https://www.googleapis.com/youtube/v3/search"
search_data = {
"part": "snippet",
"key": self.youtube_api_key,
"order": "relevance",
"safesearch": "none",
"type": "video",
"max-results": 5,
"q": q,
}
query = q.replace(" ", "+")
url = "https://www.youtube.com/results?search_query=" + query
response = urllib2.urlopen(url)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
video_ids = []
output = []
for vid in soup.findAll(attrs={'class': 'yt-uix-tile-link'}):
video_ids.append(vid['href'][9:])
print(vid)
sr = {
"video_id":
vid['href'],
"url":
"https://www.youtube.com/watch?v={0}".format(vid['href'][9:]),
"title":
vid['title'],
"thumbnail":
"no",
"publish_time":
"no",
"views":
"no",
"duration": (1, 1)
}
output.append(sr)
# output.append(sr)
#youtube_video_url = "https://www.googleapis.com/youtube/v3/videos"
#video_data = {
# "part": "contentDetails,snippet,statistics",
# "key": self.youtube_api_key,
# "id": ",".join(video_ids),
#}
#video_form_data = urllib.urlencode(video_data)
#video_results = yield http_client.fetch(youtube_video_url + "?" + video_form_data)
#video_json = json.loads(video_results.body)
#output = []
#for yi in video_json['items']:
# sr = {
# "video_id": yi["id"],
# "url": "http://www.youtube.com/watch?v={0}".format(yi["id"]),
# "title": yi["snippet"]["title"],
# "thumbnail": yi["snippet"]["thumbnails"]["default"]["url"],
# "publish_time": yi["snippet"]["publishedAt"],
# "views": yi["statistics"]["viewCount"],
#"duration": self.parse_duration(yi["contentDetails"]["duration"]),
#}
#output.append(sr)
self.youtube_cache[q] = output
raise service.Return(output)
def cmd_vote(self, message):
raise service.Return("Not Implemented")
def get_state(self):
raise service.Return(
{name: self.devices[name].state
for name in self.devices})
def cmd_youtube_raw(self, q, url):
yield self.queue_cmd("add", {"type": "youtube", "args": {"url": url}})
raise service.Return(u'Queued text.')
def cmd_say(self, q, text):
yield self.queue_cmd("add", {"type": "text", "args": {"text": text}})
raise service.Return(u'Queued text.')
def cmd_get_vol(self, q):
result = yield self.vol_cmd("get_vol")
raise service.Return("Volume is {0}".format(
result.get("vol", "unknown")))
