def start(update, context): if is_public_chat(update, context): remove_command(context, update) bot_hello = context.bot.send_message( chat_id=update.effective_message.chat.id, text=messages.msg_start, parse_mode=ParseMode.HTML) cleaner(context, bot_hello) else: username = update.message.from_user.first_name chat_id = update.effective_message.chat.id try: LOGGER.info(f'Subscription token message {update.message.text}') telegram_unique_token = update.message.text.split('/start ')[1] params = { 'telegram_unique_token': telegram_unique_token, 'chat_id': chat_id } x = requests.post(EXCHANGE_URL, data=params) LOGGER.info(f'Subscription response {x.status_code} {x.text}') if x.status_code == 200: message = messages.msg_subscribe.format(username, chat_id) context.bot.send_message(chat_id, message, parse_mode=ParseMode.HTML) else: message = messages.msg_subscribe_error context.bot.send_message(chat_id, message, parse_mode=ParseMode.HTML) except Exception as e: message = messages.msg_default_start.format(username) context.bot.send_message(chat_id, message, parse_mode=ParseMode.HTML) LOGGER.warning(f'<start> Exception Occured: {str(e)}')
def handleTraceback(object): context = object.context entry_url = object.entry_url if entry_url is None: return LOGGER.info("handle traceback [%s]" % entry_url) try: cleanup_lock.acquire() # we don't want to produce any errors here, thus, we'll be nice and die # silently if an error occurs here try: transaction.begin() # get our logbook view to use the api logbook = context.unrestrictedTraverse('@@logbook') # get the generated error url from Products.SiteErrorLog err_id = urllib.splitvalue(entry_url)[1] # save error logbook.save_error(err_id, context=aq_parent(context)) transaction.get().note('collective.logbook traceback [%s]' % entry_url) transaction.commit() finally: cleanup_lock.release() # only warning except Exception, e: LOGGER.warning("An error occured while handling the traceback") LOGGER.warning("%s" % e) LOGGER.exception(e)
def translate(context, update): if AUTO_TRANSLATE is True: # Checks if Language is English, if Confident it isn't Translate & Reply msg_text = context.effective_message.text lang, confidence = identifier.classify(msg_text) if lang != "en" and confidence >= 0.9: try: # Create Langpair to Show Translation API What We Need langpair = lang + '|en' translated_msg = requests.get( 'https://api.mymemory.translated.net/get', params={ 'q': msg_text, 'key': MYMEMORY_KEY, # API Key 'langpair': langpair, 'de': MYMEMORY_CONTACT # Contact Email }).json() # Grab Translated Text from Nested JSON Response final_translation = translated_msg['matches'][0]['translation'] # Respond with Translation to Non-English Message context.effective_message.reply_text( messages.msg_translate.format(final_translation), parse_mode='HTML') except Exception as e: LOGGER.warning(f'Translation Failed - {str(e)}') else: return
def gas(update, context): # Show Current Estimates for Gas prices remove_command(context, update) try: resp = requests.get("https://api.etherscan.io/api?module=gastracker&action=gasoracle") if resp.status_code == 200: prices = resp.json() low = prices['result']['SafeGasPrice'] standard = prices['result']['ProposeGasPrice'] fast = prices['result']['FastGasPrice'] message = messages.msg_gas.format(fast, standard, low) gas_msg = context.bot.send_message( chat_id=update.effective_message.chat.id, text=message, parse_mode=ParseMode.HTML, disable_web_page_preview=True ) cleaner(context, gas_msg) except TypeError as e: LOGGER.warning(f'Rate Limited - {str(e)}') message = "Sorry Unable to Fetch Gas Estimates Right Now..." gas_message = context.bot.send_message( chat_id=update.effective_message.chat.id, text=message, parse_mode=ParseMode.HTML ) cleaner(context, gas_message)
def delete_bot_message(update, context): try: context.bot.deleteMessage( chat_id=update.effective_message.chat.id, message_id=update.effective_message.message_id ) except BaseException as e: LOGGER.warning(f'<delete_bot_message> Exception Occured: {str(e)}') pass
def save(self): self.detected_images = self.detect() if self.output_directory is not None: if not os.path.isdir(self.output_directory): os.mkdir(self.output_directory) for name, detected_image in self.detected_images.items(): cv2.imwrite(f"{self.output_directory}/{name}", detected_image) else: LOGGER.warning( "Please provide output directory where images will be saved..." )
def run(): # TODO: break this into smaller functions LOGGER.info('Running music downloader...') tracks_to_download = get_tracks_to_download() if not tracks_to_download: LOGGER.info('No queued tracks found in database') return LOGGER.info('Found {} tracks from database to download...'.format(len(tracks_to_download))) options = { 'format': 'bestaudio/best', 'postprocessors': [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192', }], 'quiet': False} for queued_track in tracks_to_download: exists = session.query(SavedTrack).filter(SavedTrack.artist == queued_track.artist, SavedTrack.title == queued_track.title).count() > 0 if exists: LOGGER.info('Track already exists as Saved Track, deleting Queued track and skipping download.') session.delete(queued_track) session.commit() continue track_save_name = u'{} - {}'.format(queued_track.artist, queued_track.title) final_track_path = TRACK_DIRECTORY + track_save_name + '.mp3' holding_track_path = HOLD_DIRECTORY + track_save_name + '.mp3' LOGGER.info('Downloading track: {}'.format(track_save_name)) options['outtmpl'] = u'{}/{}.%(ext)s'.format(HOLD_DIRECTORY, track_save_name) ydl = youtube_dl.YoutubeDL(options) download_link = build_download_link(queued_track.youtube_video_id) # download the track try: ydl.download([download_link]) except youtube_dl.utils.DownloadError as e: LOGGER.warning('youtube-dl encountered an error: {}' .format(e.message)) continue saved_track = SavedTrack() saved_track.update_from_dict(queued_track.as_dict()) saved_track.path = final_track_path saved_track.md5 = calculate_md5(holding_track_path) fingerprint_duration = fingerprint_file(holding_track_path, 30) saved_track.fingerprint = fingerprint_duration[1] saved_track.duration = fingerprint_duration[0] session.merge(saved_track) session.delete(queued_track) session.commit() os.rename(holding_track_path, final_track_path) LOGGER.info('Complete. Downloaded track data committed to database.')
def subscribe(update, context): try: username = update.message.from_user.first_name chat_id = update.effective_message.chat.id telegram_unique_token = update.message.text.split('/subscribe ')[1] params = { 'telegram_unique_token': telegram_unique_token, 'chat_id': chat_id } x = requests.post(EXCHANGE_URL, data=params) if x.status_code == 200: message = messages.msg_subscribe.format(username, chat_id) context.message.reply_text(message, parse_mode=ParseMode.HTML) else: message = messages.msg_subscribe_error context.message.reply_text(message, parse_mode=ParseMode.HTML) except Exception as e: message = messages.msg_default_start.format(username) context.message.reply_text(message, parse_mode=ParseMode.HTML) LOGGER.warning(f'<subscribe> Exception Occured: {str(e)}')
def detect_vertical(self, show=False): if self.output_directory is None: raise LOGGER.warning( "Please provide output directory where images will be saved..." ) if not os.path.isdir(self.output_directory): os.mkdir(self.output_directory) for img in self.images: [image, image_name] = [img[0], img[1]] out_h = ndimage.convolve(image, KERNEL_VERTICAL, mode='reflect') out_h *= 255 cv2.imwrite(f"{self.output_directory}/{image_name}", out_h) if show: self.plot_two(f"{ROOT_DIRECTORY}/data/{image_name}", f"{ROOT_DIRECTORY}/detected/{image_name}", tekst="Vertical line detection")
def shutdown_session(exception=None): if exception: LOGGER.warning("Shutdown Exception: %s", exception) db_session.remove()
def error(update, context): LOGGER.warning('Update "%s" caused error "%s"', update, context.error)