def run(self): """ Start the main loop. """ self.select_next_pending() delta_t = self.next_pending.time_pending() - get_date() sec_to_next = delta_t.total_seconds() sleep_time = sec_to_next - self.pre_wake_time if sec_to_next >= self.pre_wake_time: logger.info("Sleeping for %d seconds..." % sleep_time) time.sleep(sec_to_next - self.pre_wake_time) logger.info("alarm going of in %d seconds... preparing..." % self.pre_wake_time) # prepare the alarm and shit self.next_pending.prepare() logger.debug("waiting...") while self.next_pending.time_pending() > get_date(): time.sleep(1) logger.info("pling pling pling") self.next_pending.set_off() logger.info("starting over..") self.run()
def debug(self): """ Woo debugging """ logger.debug("alarm went off because of debuggingggg") self.select_next_pending() self.next_pending.prepare() self.next_pending.set_off()
def load(self, q_list): """ Takes a given list of queries in a string format and converts them into wav files which can be played later. """ logger.debug("loaded query handler") self.sound_list = self._queue_queries(q_list) self.loaded = True
def play(self, delay=0): """ Plays a prepared list of queries. """ logger.info("playing query list...") if not self.loaded: logger.warning("the query handler must be loaded to continue") return self._play_queries(delay, self.sound_list) logger.debug("played queries successfully...")
def _run(self): """ Private function that plays the loaded uncompressed file. """ while self._data != '' and self.playing: self._player.write(self._data) self._data = self._w.readframes(self._periodsize) self.playing = False time.sleep(self._end_delay) logger.debug("player thread stopped")
def __init__(self, path=None): """ Initialize a player object, either with or without a path. If it is not initalized with a path you have to use the load function to manually load object with a file. """ logger.debug("initalizing player with sound: %s" % path) # with concurrent streams you will experience # stuttering if the periodsize is too big self._periodsize = 1024 # 8192 if path != None: self.load(path)
def _get_query(self, save_name, text): """ Takes a given string and converts it into a .mp3 file, which can later be converted. """ try: li = text.split(" ") q = [] maxlen = 100 index = 0 with open(save_name, "wb") as f: for i, w in enumerate(li): neww = w + " " newlist = list(q) newlist.append(neww) newlen = len(" ".join(newlist)) if newlen >= maxlen: s = " ".join(q) logger.debug("query string: %s" % s) r = self._request_query(s, index) f.write(r) index += 1 q = [] q.append(w) else: q.append(neww) s = " ".join(q) logger.debug("query string: %s" % s) r = self._request_query(s, index) f.write(r) logger.info("successfully retrieved query translation...") return True except IOError as e: err = str(e) logger.error("ioerror saving query: %s" % err) return False
def play(self, end_delay=0, join=True): """ Play a loaded file. 'end_delay' is the number of seconds to wait before actually finishing playing. If 'join' is true the main thread will wait for this one to finish before moving along. """ logger.debug("starting player thread") self.playing = True self._end_delay = end_delay self._data = self._w.readframes(self._periodsize) self._t.start() if join: self._t.join()
def convert_mp3(filename, overwrite=False): """ Convert a .mp3 file into a .mp3 file using pydub Overwrite True will convert the file even if the file exists """ in_path = abspath(filename) out_path = abspath(splitext(filename)[0]) + ".wav" logger.debug("converting file .mp3 to .wav:") logger.debug(" <- %s" % in_path) logger.debug(" -> %s" % out_path) if not isfile(out_path) or overwrite: AudioSegment.from_file(in_path).export(out_path, format="wav") logger.debug("conversion completed successfully...") else: logger.debug("file already exist.. skipping conversion..") return out_path
def _queue_queries(self, queries): """ Retrieves and converts a list of queries and returns a list of the paths to the converted .wav files. """ sounds = [] for i, q in enumerate(queries): template = "query/query-%d.%s" name = template % (i, "mp3") ret = self._get_query(name, q) if ret: wav = convert_mp3(name, True) sounds.append(wav) logger.info("queued up sound: %s" % wav) logger.debug(wav) else: logger.warning("failed to retreieve query: %s" % wav) return sounds
def load(self, path): """ Loads a uncompressed music file into the object. This can be called as many times as you would like during the lifetime of the object, as long as the previous file has finished playing. """ logger.debug("loading player with sound: %s" % path) p = os.path.abspath(path) self.playing = False self._w = wave.open(p) self._player = aa.PCM(aa.PCM_PLAYBACK, aa.PCM_NORMAL) self._player.setchannels(self._w.getnchannels()) self._player.setrate(self._w.getframerate()) self._player.setformat(aa.PCM_FORMAT_S16_LE) self._player.setperiodsize(self._periodsize) self._t = threading.Thread(target=self._run)
def select_next_pending(self): """ Select and set the next pending alarm. """ if not (len(self.pool) > 0): logger.warning("found no alarms... exiting") sys.exit(1) date = get_date() lowest = self.pool[0] for a in self.pool: logger.debug("] %s" % str(a.time_pending())) for alarm in self.pool: if alarm.time_pending() < lowest.time_pending(): lowest = alarm logger.info("next pending alarm (%s) @%s" % (lowest.name, str(lowest.time_pending()))) self.next_pending = lowest return lowest
def load(self): """ Loads the alarms, duuh """ if os.path.isfile(os.path.abspath(self.alarm_file)): logger.debug("alarms found @ %s" % self.alarm_file) else: logger.critical("could not find %s \n... exiting" % self.alarm_file) sys.exit(1) alarm_json = self._get_json(self.alarm_file) al = [] for k in alarm_json: o = alarm_json[k] a = Alarm(k, o["label"], int(o["hour"]), int(o["minute"]), o["days"], o["options"]) al.append(a) self.pool = al logger.debug("loaded %d alarms..." % len(self.pool))
def _play_queries(self, delay, sounds): """ Itterates over a given list of queries and plays them with a given delay after each one. """ logger.debug("playing query queue...") p = Player() idx = 0 maxidx = len(sounds) while idx < maxidx: p.load(sounds[idx]) logger.debug("playing and then delaying for %d seconds..." % delay) p.play(delay, True) idx += 1 logger.debug("played queue successfully...")