def edit_history_delete_old_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): db_session = Session() size = get_keyboard_size(update.message.chat_id) subquery = (db_session.query( ChatRequests.id).filter_by(chat_id=update.message.chat_id).order_by( ChatRequests.times.desc()).limit(size)) db_session.query(ChatRequests).filter( ChatRequests.chat_id == update.message.chat_id, ChatRequests.id.notin_(subquery)).delete(synchronize_session="fetch") transaction.commit() text_to = _("History of hidden requests has been cleared.") keyboard = get_keyboard_deletion(update.message.chat_id, _) update.message.reply_text(parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard, text=text_to) return SettingsSteps.onscreen_menu_edit_history
def set_command(update: Update, context: CallbackContext, chat_info: dict, _: gettext): if update.message.text.endswith("___"): default_currency_position = False elif update.message.text.startswith("___"): default_currency_position = True else: update.message.reply_text(text="π§") return SettingsSteps.default_currency_position if default_currency_position: position = f'___{chat_info["default_currency"]}' else: position = f'{chat_info["default_currency"]}___' db_session = Session() db_session.query(Chat).filter_by(id=update.message.chat_id).update( {"default_currency_position": default_currency_position}) transaction.commit() text_to = _( "*%(position)s* - position where your default currency will be added." ) % { "position": position } update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) main_menu(update, chat_info, _) return SettingsSteps.main
def set_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): currency_code = update.message.text.upper() db_session = Session() currency = ( db_session.query(Currency).filter_by(code=currency_code, is_active=True).first() ) if not currency: update.message.reply_text(text="π§") return SettingsSteps.default_currency db_session.query(Chat).filter_by(id=update.message.chat_id).update( {"default_currency": currency_code} ) transaction.commit() text_to = _("*%(default_currency)s* is your default currency.") % { "default_currency": currency_code } update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) main_menu(update, chat_info, _) return SettingsSteps.main
def write_request_log(chat_id: int, msg: str, created_at: datetime, tag: str = "") -> None: if len(msg) > settings.MAX_LEN_MSG_REQUESTS_LOG: return db_session = Session() db_session.add( RequestsLog(chat_id=chat_id, message=msg, tag=tag, created_at=created_at)) transaction.commit()
def start_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): if update.message.chat.type == "private": name = update.message.from_user.first_name else: name = _("humans") update.message.reply_text(text=_("Hello, %(name)s!") % {"name": name}) if chat_info["created"]: tutorial(update, _) else: if not chat_info["is_subscribed"]: Session().query(Chat).filter_by(id=update.message.chat_id).update( {"is_subscribed": true()}) transaction.commit() keyboard = get_keyboard(update.message.chat_id) update.message.reply_text( reply_markup=ReplyKeyboardMarkup(keyboard) if keyboard else None, text=_("Have any question how to talk with me? Γ°ΕΈββ° /tutorial"), ) return ConversationHandler.END
def get_all_currencies(): return ( Session.query(Currency.code, Currency.name) .filter_by(is_active=True) .order_by(Currency.name) .all() )
def parse(self) -> PriceRequest: text = self.text obj = AMOUNT_PATTERN_COMPILED.match(text) if not obj: raise WrongFormatException amount = obj[0] if amount: amount = parse_amount(amount, self.locale) last_request = (Session.query(ChatRequests).filter_by( chat_id=self.chat_id).order_by( ChatRequests.modified_at.desc()).first()) if not last_request: raise WrongFormatException locale = Locale(self.locale) if locale.character_order == "right-to-left": direction_writing = DirectionWriting.RIGHT2LEFT else: direction_writing = DirectionWriting.LEFT2RIGHT return PriceRequest( amount=amount, currency=last_request.from_currency.code, to_currency=last_request.to_currency.code, parser_name=self.name, direction_writing=direction_writing, )
def stop_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): if chat_info["is_subscribed"]: Session().query(Chat).filter_by(id=update.message.chat_id).update( {"is_subscribed": false()}) transaction.commit() update.message.reply_text(text=_( "You're unsubscribed. You always can subscribe again Γ°ΕΈββ° /start")) Session().query(Notification).filter_by( is_active=true(), chat_id=update.message.chat_id).update({"is_active": false()}) transaction.commit() return ConversationHandler.END
def visibility_set(update: Update, chat_info: dict, _: gettext, is_show_keyboard: bool): db_session = Session() chat = db_session.query(Chat).filter_by(id=update.message.chat_id).first() chat.is_show_keyboard = is_show_keyboard transaction.commit() if is_show_keyboard: text_to = _( "On-screen menu below with a history requests will *always shows*." ) else: text_to = _( "On-screen menu below with a history requests will *never shows*.") update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) onscreen_menu(update, chat_info, _)
def get_last_request(chat_id): size = get_keyboard_size(chat_id) return ( Session.query(ChatRequests) .filter_by(chat_id=chat_id) .order_by(ChatRequests.times.desc(), ChatRequests.modified_at.asc()) .limit(size) .all() )
def rate_from_pair_data(pair_data: PairData, exchange_id: int) -> Rate: db_session = Session() try: from_currency = (db_session.query(Currency).filter_by( is_active=True, code=pair_data.pair.from_currency).one()) to_currency = (db_session.query(Currency).filter_by( is_active=True, code=pair_data.pair.to_currency).one()) except NoResultFound: raise CurrencyNotSupportedException(pair_data.pair) return Rate( exchange_id=exchange_id, from_currency=from_currency, to_currency=to_currency, rate=pair_data.rate, rate_open=pair_data.rate_open, low24h=pair_data.low24h, high24h=pair_data.high24h, last_trade_at=pair_data.last_trade_at, )
def delete_expired_rates() -> None: db_session = Session() current_time = datetime.utcnow() two_days_ago = current_time - timedelta(days=2) rates = db_session.query(Rate).filter(Rate.last_trade_at < two_days_ago) for r in rates: logging.warning( "Rate expired exchange: %s, pair: %s-%s", r.exchange.name, r.from_currency.code, r.to_currency.code, ) rates.delete() try: transaction.commit() except (IntegrityError, OperationalError): logging.exception("Error delete expired") transaction.abort()
def send_notification(self, chat_id: int, text: str) -> None: """ https://core.telegram.org/bots/faq#how-can-i-message-all-of-my-bot-39s-subscribers-at-once The API will not allow more than ~30 messages to different users per second """ bot = Bot(settings.BOT_TOKEN) try: bot.send_message( chat_id=chat_id, disable_web_page_preview=True, parse_mode=ParseMode.MARKDOWN, text=text, ) except TimedOut as e: raise self.retry(exc=e) except RetryAfter as e: raise self.retry(exc=e, countdown=int(e.retry_after)) except Unauthorized: # bot deleted db_session = Session() db_session.query(Notification).filter_by(is_active=true(), chat_id=chat_id).update( {"is_active": false()}) db_session.query(Chat).filter_by(id=chat_id).update( {"is_subscribed": false()}) transaction.commit()
def edit_history_delete_all_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): Session().query(ChatRequests).filter_by( chat_id=update.message.chat_id).delete() transaction.commit() text_to = _("History requests has been cleared fully.") update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) onscreen_menu(update, chat_info, _) return SettingsSteps.onscreen_menu
def set_size_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): if update.message.text not in KEYBOARD_SIZES: update.message.reply_text(text="π§") return SettingsSteps.onscreen_menu_size text_to = _( "%(keyboard_size)s - size of on-screen menu with a history requests was changed." ) % { "keyboard_size": update.message.text } db_session = Session() db_session.query(Chat).filter_by(id=update.message.chat_id).update( {"keyboard_size": update.message.text}) transaction.commit() update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) onscreen_menu(update, chat_info, _) return SettingsSteps.onscreen_menu
def set_callback(update: Update, context: CallbackContext, chat_info: dict): if update.message.text not in settings.LANGUAGES_NAME: update.message.reply_text(text="π§") return SettingsSteps.language else: locale = settings.LANGUAGES_NAME[update.message.text] db_session = Session() db_session.query(Chat).filter_by(id=update.message.chat_id).update( {"locale": locale}) transaction.commit() _ = get_translations(locale) text_to = _("*%(language)s* is your language now.") % { "language": LOCALE_NAME[locale] } update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) main_menu(update, chat_info, _) return SettingsSteps.main
def wrapper(update: Update, context: CallbackContext, *args, **kwargs): if not update.effective_user: # bots, may be exclude in filter messages return if update.effective_chat: # we need settings for a group chats, not for a specific user # private chat id == user id chat_id = update.effective_chat.id else: # inline commands, get settings for his private chat chat_id = update.effective_user.id if update.effective_user.language_code: # chats don't have language_code, that why we take from user, not so correct yes # they will able change language later # https://en.wikipedia.org/wiki/IETF_language_tag language_code = update.effective_user.language_code.lower() else: # some users don't have locale, set default language_code = settings.LANGUAGE_CODE db_session = Session() chat = db_session.query(Chat).filter_by(id=chat_id).first() if not chat: chat = Chat( id=chat_id, locale=language_code, is_show_keyboard=True if chat_id > 0 else False, # never show keyboard for a group chats ) db_session.add(chat) try: transaction.commit() chat_created = True except IntegrityError: chat_created = False logging.exception("Error create chat, chat exists") transaction.abort() finally: chat = db_session.query(Chat).filter_by(id=chat_id).one() else: chat_created = False kwargs["chat_info"] = { "chat_id": chat.id, "created": chat_created, "locale": chat.locale, "is_subscribed": chat.is_subscribed, "is_show_keyboard": chat.is_show_keyboard, "keyboard_size": chat.keyboard_size, "default_currency": chat.default_currency, "default_currency_position": chat.default_currency_position, } return func(update, context, *args, **kwargs)
def notification_auto_disable(pair: list) -> None: db_session = Session() notifications = (db_session.query(Notification).filter_by( is_active=true(), from_currency_id=pair[0], to_currency_id=pair[1]).all()) for n in notifications: _ = get_translations(n.chat.locale) send_notification.delay( n.chat_id, _("Your notification has been disabled, due to one of the currencies" " %(from_currency)s %(to_currency)s has been deactivated.") % { "from_currency": n.from_currency.code, "to_currency": n.to_currency.code, }, ) db_session.query(Notification).filter_by(is_active=true(), from_currency_id=pair[0], to_currency_id=pair[1]).update( {"is_active": false()}) transaction.commit()
def newsletter(file_text, for_all): try: text = open(file_text, "r").read() except FileNotFoundError: click.echo("File not found.") return if for_all: click.echo("Will start delivery for all...") time.sleep(5) db_engine = create_engine(settings.DATABASE["url"]) init_sqlalchemy(db_engine) chats = Session.query(Chat.id).filter_by(is_subscribed=True).order_by( Chat.id) if not for_all: chats = chats.filter_by(id=settings.DEVELOPER_USER_ID) for chat in chats.yield_per(100): send_notification.delay(chat.id, text)
def edit_history_delete_one_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): parts = update.message.text.split(" ") db_session = Session() from_currency = db_session.query(Currency).filter_by(code=parts[1]).first() to_currency = db_session.query(Currency).filter_by(code=parts[2]).first() if not from_currency or not to_currency: update.message.reply_text(text="π§") else: db_session.query(ChatRequests).filter_by( chat_id=update.message.chat_id, from_currency=from_currency, to_currency=to_currency, ).delete() transaction.commit() text_to = _("*%(first)s %(second)s* was deleted.") % { "first": parts[1], "second": parts[2], } if have_last_request(update.message.chat_id): keyboard = get_keyboard_deletion(update.message.chat_id, _) update.message.reply_text(parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard, text=text_to) return SettingsSteps.onscreen_menu_edit_history else: update.message.reply_text(parse_mode=ParseMode.MARKDOWN, text=text_to) onscreen_menu(update, chat_info, _) return SettingsSteps.onscreen_menu
def update_chat_request(chat_id: int, from_currency: str, to_currency: str): db_session = Session() from_currency = db_session.query(Currency).filter_by( code=from_currency).one() to_currency = db_session.query(Currency).filter_by(code=to_currency).one() chat_request = (db_session.query(ChatRequests).filter_by( chat_id=chat_id, from_currency=from_currency, to_currency=to_currency).first()) if chat_request: chat_request.times = ChatRequests.times + 1 else: chat_request = ChatRequests(chat_id=chat_id, from_currency=from_currency, to_currency=to_currency) db_session.add(chat_request) try: transaction.commit() except (IntegrityError, OperationalError): logging.exception("Error create chat_request, chat_request exists") transaction.abort()
def get_all_currency_codes(): codes = ( Session.query(Currency.code).filter_by(is_active=True).order_by(Currency.code) ) return [x[0] for x in codes]
def have_last_request(chat_id): return Session.query(ChatRequests).filter_by(chat_id=chat_id).first()
def get_keyboard_size(chat_id): chat = Session.query(Chat.keyboard_size).filter_by(id=chat_id).first() w, h = chat[0].split("x") return int(w) * int(h)
def exchange_updater(exchange_class: str) -> None: db_session = Session() exchange = import_app_module(exchange_class)() try: exchange_obj = db_session.query(Exchange).filter_by( name=exchange.name).one() if not exchange_obj.is_active: logging.info(f"Exchange: {exchange.name} is not active, skip.") return except NoResultFound: logging.error(f"Exchange: {exchange.name} is not configured, skip.") return logging.info(f"Exchange: {exchange.name} in process.") for pair in exchange.list_pairs: from_currency = (db_session.query(Currency).filter_by( is_active=True, code=pair.from_currency).scalar()) to_currency = (db_session.query(Currency).filter_by( is_active=True, code=pair.to_currency).scalar()) if not from_currency or not to_currency: logging.debug( f"Exchange: {exchange.name}, pair: {pair} is not active or not supported, skip." ) continue def save_rate(the_pair_data: PairData) -> None: new_rate = rate_from_pair_data(the_pair_data, exchange_obj.id) current_rate = (db_session.query(Rate).filter_by( from_currency=new_rate.from_currency, to_currency=new_rate.to_currency, exchange_id=exchange_obj.id, ).first()) new_rate = fill_rate_open(new_rate, current_rate) if current_rate: new_rate.id = current_rate.id db_session.merge(new_rate) else: db_session.add(new_rate) pair_data = exchange.get_pair_info(pair) current_time = datetime.utcnow() week_ago = current_time - timedelta(days=7) if pair_data.last_trade_at < week_ago: logging.debug( "Rate expired exchange: %s, pair: %s-%s", exchange.name, pair.from_currency.code, pair.to_currency.code, ) continue save_rate(pair_data) if not exchange.included_reversed_pairs: reversed_pair_data = reverse_pair_data(pair_data) save_rate(reversed_pair_data) try: transaction.commit() except (IntegrityError, OperationalError): logging.exception("Error to fill rate pair") transaction.abort()
def notification_checker() -> None: db_session = Session() pairs = (db_session.query( Notification.from_currency_id, Notification.to_currency_id).filter_by(is_active=true()).group_by( Notification.from_currency_id, Notification.to_currency_id).all()) for pair in pairs: from_currency = db_session.query(Currency).get(pair[0]) to_currency = db_session.query(Currency).get(pair[1]) if not from_currency.is_active or not to_currency.is_active: logging.info( "Disable notifications because currency %s %s is not active anymore", from_currency.code, to_currency.code, ) notification_auto_disable(pair) continue pr = PriceRequest( amount=None, currency=from_currency.code, to_currency=to_currency.code, parser_name="Notification", ) prr = convert(pr) notifications = (db_session.query(Notification).filter_by( is_active=true()).filter_by(from_currency_id=pair[0], to_currency_id=pair[1]).all()) for n in notifications: if is_triggered(n.trigger_clause, n.trigger_value, n.last_rate, prr.rate): # replace rate_open from daily to rate when was created or last triggered notification # TODO: PriceRequestResult -> dataclass, inside diff and etc nprr = PriceRequestResult( price_request=prr.price_request, exchanges=prr.exchanges, rate=prr.rate, rate_open=n.last_rate, last_trade_at=prr.last_trade_at, low24h=prr.low24h, high24h=prr.high24h, ) text_to = NotifyFormatPriceRequestResult(nprr, n.chat.locale).get() if n.trigger_clause in [ NotifyTriggerClauseEnum.less, NotifyTriggerClauseEnum.more, ]: n.is_active = False _ = get_translations(n.chat.locale) text_to += "\n" text_to += _("_One-time reminder. Set up a new reminder._") send_notification.delay(n.chat_id, text_to) n.last_rate = prr.rate transaction.commit()
def convert(price_request: PriceRequest) -> PriceRequestResult: if price_request.currency == price_request.to_currency: return PriceRequestResult( price_request=price_request, exchanges=["Baba Vanga"], rate=Decimal("1"), last_trade_at=datetime(1996, 8, 11), ) if price_request.amount == 0: return PriceRequestResult( price_request=price_request, exchanges=["Baba Vanga"], rate=Decimal("0"), last_trade_at=datetime(1996, 8, 11), ) from_currency = Session.query(Currency).filter_by( code=price_request.currency).one() to_currency = (Session.query(Currency).filter_by( code=price_request.to_currency).one()) rate_obj = (Session.query(Rate).filter_by( from_currency=from_currency, to_currency=to_currency).join(Exchange).filter( Exchange.is_active == sa.true()).order_by(sa.desc( Exchange.weight)).first()) if rate_obj: price_request_result = PriceRequestResult( price_request=price_request, exchanges=[rate_obj.exchange.name], rate=rate_obj.rate, rate_open=rate_obj.rate_open, last_trade_at=rate_obj.last_trade_at, low24h=rate_obj.low24h, high24h=rate_obj.high24h, ) else: rate0_model = orm.aliased(Rate) rate1_model = orm.aliased(Rate) exchange0_model = orm.aliased(Exchange) exchange1_model = orm.aliased(Exchange) rate_obj = (Session.query( rate0_model, rate1_model, (exchange0_model.weight + exchange1_model.weight).label("w"), ).filter_by(from_currency=from_currency).join( rate1_model, sa.and_( rate1_model.from_currency_id == rate0_model.to_currency_id, rate1_model.to_currency == to_currency, ), ).join( exchange0_model, sa.and_( exchange0_model.id == rate0_model.exchange_id, exchange0_model.is_active == sa.true(), ), ).join( exchange1_model, sa.and_( exchange1_model.id == rate1_model.exchange_id, exchange1_model.is_active == sa.true(), ), ).order_by(sa.desc("w")).first()) if rate_obj: rate = combine_values(rate_obj[0].rate, rate_obj[1].rate) rate_open = combine_values(rate_obj[0].rate_open, rate_obj[1].rate_open) low24h = high24h = None price_request_result = PriceRequestResult( price_request=price_request, exchanges=[ rate_obj[0].exchange.name, rate_obj[1].exchange.name ], rate=rate, rate_open=rate_open, last_trade_at=min(rate_obj[0].last_trade_at, rate_obj[1].last_trade_at), low24h=low24h, high24h=high24h, ) else: raise NoRatesException check_overflow(price_request_result) return price_request_result