async def handler(self, event: events.ChatAction, request_context: RequestContext): schema, session_id, old_message_id, document_id, position, page = self.parse_pattern(event) request_context.add_default_fields(mode='view', session_id=session_id) request_context.statbox(action='view', document_id=document_id, position=position, schema=schema) has_found_old_widget = old_message_id == self.application.user_manager.last_widget.get(request_context.chat.chat_id) try: message_id, link_preview = await self.process_widgeting( has_found_old_widget=has_found_old_widget, old_message_id=old_message_id, request_context=request_context ) document_view = await self.resolve_document( schema, document_id, position, session_id, request_context, ) try: back_command = await self.compose_back_command( session_id=session_id, message_id=message_id, page=page, ) except MessageHasBeenDeletedError: return await event.respond( t('REPLY_MESSAGE_HAS_BEEN_DELETED', language=request_context.chat.language), ) view, buttons = document_view.get_view( language=request_context.chat.language, session_id=session_id, bot_external_name=self.application.config['telegram']['bot_external_name'], position=position, back_command=back_command, ) actions = [ self.application.telegram_client.edit_message( request_context.chat.chat_id, message_id, view, buttons=buttons, link_preview=link_preview, ), event.delete(), ] if not has_found_old_widget: actions.append( self.application.telegram_client.delete_messages( request_context.chat.chat_id, [old_message_id], ) ) return await asyncio.gather(*actions) except MessageIdInvalidError: await event.reply(t("VIEWS_CANNOT_BE_SHARED", language=request_context.chat.language))
async def handler(self, event: events.ChatAction, request_context: RequestContext): schema, session_id, document_id, vote, vote_value = self.parse_pattern( event) request_context.add_default_fields(mode='vote', session_id=session_id) request_context.statbox( action='vote', document_id=document_id, query=vote, schema=schema, ) document_operation_pb = DocumentOperationPb(vote=VotePb( document_id=document_id, value=vote_value, voter_id=request_context.chat.chat_id, ), ) logging.getLogger('operation').info( msg=MessageToDict(document_operation_pb), ) message = await event.get_message() # ToDo: Generalize nexus.views.telegram.common.remove_button and use it here return await asyncio.gather( self.application.telegram_client.edit_message( request_context.chat.chat_id, message.id, message.text, buttons=None, ), event.answer(t('TANKS_BRUH')), )
async def handler(self, event: events.ChatAction, request_context: RequestContext): session_id = self.generate_session_id() request_context.add_default_fields(mode='roll', session_id=session_id) request_context.statbox(action='show') roll_response_pb = await self.application.meta_api_client.roll( language=request_context.chat.language, session_id=session_id, request_id=request_context.request_id, user_id=str(request_context.chat.chat_id), ) scitech_view = await self.resolve_scitech( document_id=roll_response_pb.document_id, position=0, request_context=request_context, session_id=session_id, ) view, buttons = scitech_view.get_view( language=request_context.chat.language, session_id=session_id, bot_external_name=self.application.config['telegram'] ['bot_external_name'], ) actions = [ self.application.telegram_client.send_message( request_context.chat.chat_id, view, buttons=buttons, ), event.delete(), ] return await asyncio.gather(*actions)
async def handler(self, event: events.ChatAction, request_context: RequestContext): query = event.pattern_match.group(1) if query: request_context.statbox( action='show', mode='copyright', query=query, ) await self.application.telegram_client.forward_messages( self.application.config['telegram'] ['copyright_infringement_account'], event.message, ) await event.reply( t( 'COPYRIGHT_INFRINGEMENT_ACCEPTED', language=request_context.chat.language, )) else: request_context.statbox(action='show', mode='copyright') await event.reply( t( 'COPYRIGHT_DESCRIPTION', language=request_context.chat.language, ))
async def handler(self, event: events.ChatAction, request_context: RequestContext): chat_id, ban_duration, ban_message, ban_end_date = self.parse_pattern( event) try: await self.application.idm_client.update_chat( chat_id=chat_id, ban_until=int(ban_end_date.timestamp()), ban_message=ban_message, request_id=request_context.request_id, ) request_context.statbox( action='banned', ban_message=ban_message, ban_until=ban_end_date.timestamp(), banned_chat_id=chat_id, ) except ClientError as e: if e.code == 'nonexistent_entity_error': await event.reply('Chat not found') return raise await event.reply('User banned until ' + ban_end_date.strftime("%Y-%m-%d %H:%M") + ' UTC')
async def _send_fail_response(self, event, request_context: RequestContext): try: await event.answer( t('MAINTENANCE_WO_PIC', language=request_context.chat.language)) except (ConnectionError, QueryIdInvalidError) as e: request_context.error_log(e)
async def handler(self, event, request_context: RequestContext): request_context.statbox(action='show', mode='banlist') chat_list = (await self.application.idm_client.list_chats( banned_at_moment=int(datetime.utcnow().timestamp()), request_id=request_context.request_id, )).chats banlist_widget_view = BanlistWidget(application=self.application, chat=request_context.chat) widget_content = await banlist_widget_view.render(chat_list=chat_list) await event.reply(widget_content)
async def _send_fail_response(self, event: events.ChatAction, request_context: RequestContext): try: await event.reply(t( 'MAINTENANCE', language=request_context.chat.language).format( maintenance_picture_url=self.application. config['application']['maintenance_picture_url'], ), buttons=[close_button()]) except (ConnectionError, QueryIdInvalidError) as e: request_context.error_log(e)
async def handler(self, event: events.ChatAction, request_context: RequestContext): request_context.statbox(action='show', mode='help') if event.is_group or event.is_channel: await event.reply(t('HELP_FOR_GROUPS', language=request_context.chat.language), buttons=Button.clear()) else: await event.reply(t('HELP', language=request_context.chat.language), buttons=Button.clear())
async def handler(self, event: events.ChatAction, request_context: RequestContext): query = event.pattern_match.group(1) request_context.statbox(action='start', mode='shortlink', query=query) try: bot_name = self.application.config["telegram"]["bot_external_name"] text = encode_query_to_deep_link(query, bot_name) except TooLongQueryError: text = t('TOO_LONG_QUERY_FOR_SHORTLINK', language=request_context.chat.language), return await event.reply(f'`{text}`', link_preview=False)
async def handler(self, event: events.ChatAction, request_context: RequestContext): request_context.add_default_fields(mode='settings_router') request_context.statbox(action='show') settings_widget = SettingsWidget( application=self.application, chat=request_context.chat, is_group_mode=event.is_group or event.is_channel, request_id=request_context.request_id, ) text, buttons = await settings_widget.render() await event.reply(text, buttons=buttons)
async def handler(self, event, request_context: RequestContext): session_id = self.generate_session_id() request_context.add_default_fields(mode='top_missed', session_id=session_id) request_context.statbox() prefetch_message = await event.reply(t("SEARCHING", language=request_context.chat.language)) message_id = prefetch_message.id return await self.do_request( request_context=request_context, session_id=session_id, message_id=message_id, page=0, )
async def handler(self, event: events.ChatAction, request_context: RequestContext): raw_query = event.pattern_match.group(1) query = None request_context.statbox(action='start', mode='start') try: query = decode_deep_query(raw_query) except DecodeDeepQueryError as e: request_context.error_log(e, mode='start', raw_query=raw_query) if query: request_context.statbox(action='query', mode='start', query=query) request_message = await self.application.telegram_client.send_message(event.chat, query) prefetch_message = await request_message.reply( t("SEARCHING", language=request_context.chat.language), ) self.application.user_manager.last_widget[request_context.chat.chat_id] = prefetch_message.id await asyncio.gather( event.delete(), self.do_search(event, request_context, prefetch_message, query=query, is_shortpath_enabled=True), ) else: request_context.statbox(action='show', mode='start') await event.reply(t('HELP', language=request_context.chat.language))
async def handler(self, event: events.ChatAction, request_context: RequestContext): session_id = self.generate_session_id() request_context.add_default_fields(session_id=session_id) request_context.statbox(action='show', mode='submit') if event.document.mime_type != 'application/pdf': request_context.statbox(action='unknown_file_format') request_context.error_log( UnknownFileFormatError(format=event.document.mime_type)) return await asyncio.gather( event.reply( t('UNKNOWN_FILE_FORMAT_ERROR', language=request_context.chat.language), buttons=[close_button()], ), event.delete(), ) return await asyncio.gather( self.application.hub_client.submit( telegram_document=bytes(event.document), telegram_file_id=event.file.id, chat=request_context.chat, request_id=request_context.request_id, session_id=session_id, ), event.delete(), )
async def handler(self, event: events.ChatAction, request_context: RequestContext): request_context.statbox(action='show', mode='donate') await event.reply( t('DONATE', language=request_context.chat.language).format( amazon_gift_card_recipient=config['application'].get( 'amazon_gift_card_recipient', '🚫'), amazon_gift_card_url=config['application'].get( 'amazon_gift_card_url', '🚫'), btc_donate_address=config['application'].get( 'btc_donate_address', '🚫'), libera_pay_url=config['application'].get( 'libera_pay_url', '🚫'), related_channel=config['telegram'].get('related_channel', '🚫'), ))
async def _wrapped_handler(self, event: events.ChatAction) -> None: # Checking group permissions if (event.is_group or event.is_channel) and not self.is_group_handler: return await self._check_maintenance(event=event) await self._check_read_only(event=event) request_id = RequestContext.generate_request_id( self.application.config['application']['request_id_length']) chat = await self._process_chat(event=event, request_id=request_id) request_context = RequestContext( bot_name=self.application.config['telegram']['bot_name'], chat=chat, request_id=request_id, request_id_length=self.application.config['application'] ['request_id_length'], ) if not self._has_access(chat): return await self._check_subscription(event=event, request_context=request_context, chat=chat) await self._check_ban(event=event, request_context=request_context, chat=chat) if self.should_reset_last_widget: self.reset_last_widget(request_context.chat.chat_id) async with safe_execution( request_context=request_context, on_fail=lambda: self._send_fail_response( event, request_context), ): await self.handler( event, request_context=request_context, ) if self.stop_propagation: raise events.StopPropagation()
async def handler(self, event, request_context: RequestContext): chat_id = int(event.pattern_match.group(1)) try: await self.application.idm_client.update_chat( chat_id=chat_id, ban_until=0, request_id=request_context.request_id, ) request_context.statbox( action='unbanned', unbanned_chat_id=chat_id, ) except ClientError as e: if e.code == 'nonexistent_entity_error': await event.reply('Chat not found') return raise await event.reply('User unbanned')
async def handler(self, event, request_context: RequestContext): session_id = event.pattern_match.group(1) if session_id: session_id = session_id.decode() request_context.add_default_fields(mode='close') target_events = [event.answer()] message = await event.get_message() if message: request_context.statbox( action='close', message_id=message.id, session_id=session_id, ) reply_message = await message.get_reply_message() if reply_message: target_events.append(reply_message.delete()) target_events.append(message.delete()) await asyncio.gather(*target_events)
async def handler(self, event: events.ChatAction, request_context: RequestContext): short_schema, schema, session_id, document_id, position = self.parse_pattern( event) self.application.user_manager.last_widget[ request_context.chat.chat_id] = None request_context.add_default_fields(mode='download', session_id=session_id) request_context.statbox(action='get', document_id=document_id, position=position, schema=schema) typed_document_pb = await self.get_typed_document_pb( schema=schema, document_id=document_id, request_context=request_context, session_id=session_id, position=position, ) start_delivery_response_pb = await self.application.hub_client.start_delivery( typed_document_pb=typed_document_pb, chat=request_context.chat, request_id=request_context.request_id, session_id=session_id, ) if start_delivery_response_pb.status == StartDeliveryResponsePb.Status.ALREADY_DOWNLOADING: await event.answer( f'{t("ALREADY_DOWNLOADING", language=request_context.chat.language)}', ) await remove_button(event, '⬇️', and_empty_too=True) elif start_delivery_response_pb.status == StartDeliveryResponsePb.Status.TOO_MANY_DOWNLOADS: await event.answer( f'{t("TOO_MANY_DOWNLOADS", language=request_context.chat.language)}', ) else: await remove_button(event, '⬇️', and_empty_too=True) self.application.user_manager.last_widget[ request_context.chat.chat_id] = None
async def handler(self, event: events.ChatAction, request_context: RequestContext): query = event.pattern_match.group(1) if query: request_context.statbox(action='show', mode='contact', query=query) await event.reply( t('THANK_YOU_FOR_CONTACT', language=request_context.chat.language).format( related_channel=self.application.config['telegram'] ['related_channel'], ), ) else: request_context.statbox(action='show', mode='contact') await event.reply( t('CONTACT', language=request_context.chat.language).format( btc_donate_address=config['application'] ['btc_donate_address'], libera_pay_url=config['application']['libera_pay_url'], related_channel=config['telegram']['related_channel'], ), link_preview=False, )
async def handler(self, event: events.ChatAction, request_context: RequestContext): search_prefix, query, is_group_mode = self.parse_pattern(event) request_context.add_default_fields(mode='search_edit') if is_group_mode and not search_prefix: return if not is_group_mode and search_prefix: query = event.raw_text last_messages = await self.get_last_messages_in_chat(event) try: if not last_messages: raise MessageHasBeenDeletedError() for next_message in last_messages.messages: if next_message.is_reply and event.id == next_message.reply_to_msg_id: request_context.statbox(action='resolved') return await self.do_search( event=event, request_context=request_context, prefetch_message=next_message, query=query, is_group_mode=is_group_mode, ) raise MessageHasBeenDeletedError() except MessageHasBeenDeletedError as e: request_context.error_log(e) return await event.reply( t('REPLY_MESSAGE_HAS_BEEN_DELETED', language=request_context.chat.language), )
async def handler(self, event: events.ChatAction, request_context: RequestContext): try: self.check_search_ban_timeout( user_id=str(request_context.chat.chat_id)) except BannedUserError as e: request_context.error_log(e) return await event.reply( t('BANNED_FOR_SECONDS', language=request_context.chat.language).format( seconds=e.ban_timeout, reason=t('BAN_MESSAGE_TOO_MANY_REQUESTS', language=request_context.chat.language), )) search_prefix, query, is_group_mode = self.parse_pattern(event) if is_group_mode and not search_prefix: return if not is_group_mode and search_prefix: query = event.raw_text prefetch_message = await event.reply( t("SEARCHING", language=request_context.chat.language), ) self.application.user_manager.last_widget[ request_context.chat.chat_id] = prefetch_message.id try: await self.do_search( event=event, request_context=request_context, prefetch_message=prefetch_message, query=query, is_group_mode=is_group_mode, is_shortpath_enabled=True, ) except (AioRpcError, asyncio.CancelledError) as e: await asyncio.gather( event.delete(), prefetch_message.delete(), ) raise e
async def handler(self, event, request_context: RequestContext): request_context.add_default_fields(mode='settings') action_id = event.pattern_match.group(1).decode() data = event.pattern_match.group(2).decode() request_context.statbox(action='change', query=f'action_id: {action_id} data: {data}') settings_widget = SettingsWidget( application=self.application, chat=request_context.chat, is_group_mode=event.is_group or event.is_channel, request_id=request_context.request_id, ) is_changed = await settings_widget.process_action(action_id=action_id, data=data) text, buttons = await settings_widget.render() if not is_changed and not (event.is_group or event.is_channel): await event.answer() return if event.is_group or event.is_channel: buttons = None await event.edit(text, buttons=buttons)
async def handler(self, event: events.ChatAction, request_context: RequestContext): session_id, message_id, page = self.parse_pattern(event) request_context.add_default_fields(mode='search_paging', session_id=session_id) start_time = time.time() message = await event.get_message() if not message: return await event.answer() reply_message = await message.get_reply_message() try: if not reply_message: raise MessageHasBeenDeletedError() query = self.preprocess_query(reply_message.raw_text) search_widget = await SearchWidget.create( application=self.application, chat=request_context.chat, session_id=session_id, message_id=message_id, request_id=request_context.request_id, query=query, page=page, ) except MessageHasBeenDeletedError: return await event.respond( t('REPLY_MESSAGE_HAS_BEEN_DELETED', language=request_context.chat.language), ) except AioRpcError as e: if e.code() == StatusCode.INVALID_ARGUMENT or e.code( ) == StatusCode.CANCELLED: request_context.error_log(e) return await event.answer( t('MAINTENANCE_WO_PIC', language=request_context.chat.language), ) raise e action = 'documents_found' if len(search_widget.scored_documents) == 0: action = 'documents_not_found' request_context.statbox( action=action, duration=time.time() - start_time, query=f'page:{page} query:{query}', ) serp, buttons = await search_widget.render() return await asyncio.gather( event.answer(), message.edit(serp, buttons=buttons, link_preview=False))
async def start_delivery( self, request: StartDeliveryRequestPb, context: ServicerContext, metadata: dict, ) -> StartDeliveryResponsePb: request_context = RequestContext( bot_name=self.service_name, chat=request.chat, request_id=metadata.get('request-id'), ) request_context.add_default_fields( mode='delivery', session_id=metadata.get('session-id'), **self.get_default_service_fields(), ) document_view = parse_typed_document_to_view(request.typed_document) cache_hit = self.should_use_telegram_file_id and document_view.telegram_file_id if cache_hit: try: await self.send_file( document_view=document_view, file=document_view.telegram_file_id, session_id=metadata.get('session-id'), request_context=request_context, voting=not is_group_or_channel( request_context.chat.chat_id), ) request_context.statbox(action='cache_hit', document_id=document_view.id, schema=document_view.schema) except ValueError: cache_hit = False if not cache_hit: if self.user_manager.has_task(request.chat.chat_id, document_view.id): return StartDeliveryResponsePb( status=StartDeliveryResponsePb.Status.ALREADY_DOWNLOADING) if self.user_manager.hit_limits(request.chat.chat_id): return StartDeliveryResponsePb( status=StartDeliveryResponsePb.Status.TOO_MANY_DOWNLOADS) await DownloadTask( delivery_service=self, document_view=document_view, request_context=request_context, session_id=metadata.get('session-id'), ).schedule() return StartDeliveryResponsePb( status=StartDeliveryResponsePb.Status.OK)
async def handler(self, event: events.ChatAction, request_context: RequestContext): request_context.statbox(action='show', mode='emoji') await event.reply( t('TANKS_BRUH', language=request_context.chat.language))
async def handler(self, event, request_context: RequestContext): request_context.statbox(action='show', mode='admin') admin_widget_view = AdminWidget(application=self.application, chat=request_context.chat) text = await admin_widget_view.render() await event.reply(text)
async def submit( self, request: SubmitRequestPb, context: ServicerContext, metadata: dict, ) -> SubmitResponsePb: session_id = metadata.get('session-id') request_context = RequestContext( bot_name=self.service_name, chat=request.chat, request_id=metadata.get('request-id'), ) request_context.add_default_fields( mode='submit', session_id=metadata.get('session-id'), **self.get_default_service_fields(), ) document = BinaryReader(request.telegram_document).tgread_object() if document.size > 20 * 1024 * 1024: request_context.error_log(FileTooBigError(size=document.size)) request_context.statbox(action='file_too_big') await self.telegram_client.send_message( request_context.chat.chat_id, t('FILE_TOO_BIG_ERROR', language=request_context.chat.language), buttons=[close_button()], ) return SubmitResponsePb() processing_message = await self.telegram_client.send_message( request_context.chat.chat_id, t("PROCESSING_PAPER", language=request_context.chat.language).format( filename=document.attributes[0].file_name, ), ) try: file = await self.telegram_client.download_document( document=document, file=bytes) try: processed_document = await self.grobid_client.process_fulltext_document( pdf_file=file) except BadRequestError as e: request_context.statbox(action='unparsable_document') request_context.error_log(e) await self.telegram_client.send_message( request_context.chat.chat_id, t('UNPARSABLE_DOCUMENT_ERROR', language=request_context.chat.language).format( filename=document.attributes[0].file_name, ), buttons=[close_button()], ) return SubmitResponsePb() if not processed_document.get('doi'): request_context.statbox(action='unparsable_doi') request_context.error_log(UnparsableDoiError()) await self.telegram_client.send_message( request_context.chat.chat_id, t('UNPARSABLE_DOI_ERROR', language=request_context.chat.language).format( filename=document.attributes[0].file_name, ), buttons=[close_button()], ) return SubmitResponsePb() search_response_pb = await self.meta_api_client.search( schemas=('scimag', ), query=processed_document['doi'], page=0, page_size=1, request_id=request_context.request_id, session_id=session_id, user_id=str(request_context.chat.chat_id), language=request_context.chat.language, ) if len(search_response_pb.scored_documents) == 0: request_context.statbox(action='unavailable_metadata') request_context.error_log( UnavailableMetadataError(doi=processed_document['doi'])) await self.telegram_client.send_message( request_context.chat.chat_id, t('UNAVAILABLE_METADATA_ERROR', language=request_context.chat.language).format( doi=processed_document['doi']), buttons=[close_button()], ) return SubmitResponsePb() document_view = ScimagView( search_response_pb.scored_documents[0].typed_document.scimag) uploaded_message = await self.send_file( document_view=document_view, file=file, request_context=request_context, session_id=session_id, voting=False, ) finally: await processing_message.delete() document_operation_pb = DocumentOperationPb( update_document=UpdateDocumentPb( typed_document=TypedDocumentPb(sharience=ShariencePb( parent_id=document_view.id, uploader_id=request_context.chat.chat_id, updated_at=int(time.time()), md5=hashlib.md5(file).hexdigest(), filesize=document.size, ipfs_multihashes=await self.get_ipfs_hashes(file=file), telegram_file_id=uploaded_message.file.id, )), ), ) request_context.statbox( action='success', document_id=document_view.id, schema='scimag', ) await operation_log(document_operation_pb) return SubmitResponsePb()
async def handler(self, event: events.ChatAction, request_context: RequestContext): request_context.statbox(action='start', mode='noop') await event.answer()
async def download_task(self, request_context: RequestContext, document_view): throttle_secs = 2.0 async def _on_fail(): await self.delivery_service.telegram_client.send_message( request_context.chat.chat_id, t('MAINTENANCE', language=request_context.chat.language).format( maintenance_picture_url=self.delivery_service. maintenance_picture_url), buttons=[close_button()]) async with safe_execution( request_context=request_context, on_fail=_on_fail, ): progress_bar_download = ProgressBar( telegram_client=self.delivery_service.telegram_client, request_context=request_context, banner=t("LOOKING_AT", language=request_context.chat.language), header=f'⬇️ {document_view.get_filename()}', tail_text=t('TRANSMITTED_FROM', language=request_context.chat.language), throttle_secs=throttle_secs, ) downloads_gauge.inc() start_time = time.time() try: file = await self.download( document_view=document_view, progress_bar=progress_bar_download, ) if not file: request_context.statbox( action='missed', duration=time.time() - start_time, document_id=document_view.id, schema=document_view.schema, ) is_served_from_sharience = False if self.delivery_service.is_sharience_enabled: is_served_from_sharience = await self.try_sharience( request_context=request_context, document_view=document_view, ) if not is_served_from_sharience: request_context.statbox( action='not_found', document_id=document_view.id, duration=time.time() - start_time, schema=document_view.schema, ) await self.respond_not_found( request_context=request_context, document_view=document_view, ) return else: request_context.statbox( action='downloaded', duration=time.time() - start_time, document_id=document_view.id, len=len(file), schema=document_view.schema, ) progress_bar_upload = ProgressBar( telegram_client=self.delivery_service.telegram_client, request_context=request_context, message=progress_bar_download.message, banner=t("LOOKING_AT", language=request_context.chat.language), header=f'⬇️ {document_view.get_filename()}', tail_text=t('UPLOADED_TO_TELEGRAM', language=request_context.chat.language), throttle_secs=throttle_secs) uploaded_message = await self.delivery_service.send_file( document_view=self.document_view, file=file, progress_callback=progress_bar_upload.callback, request_context=self.request_context, session_id=self.session_id, voting=not is_group_or_channel( self.request_context.chat.chat_id), ) request_context.statbox( action='uploaded', duration=time.time() - start_time, document_id=document_view.id, schema=document_view.schema, ) if self.delivery_service.should_store_hashes: asyncio.create_task( self.store_hashes( document_view=document_view, telegram_file_id=uploaded_message.file.id, file=file, )) except DownloadError: await self.external_cancel() except ProgressBarLostMessageError: self.request_context.statbox( action='user_canceled', duration=time.time() - start_time, document_id=document_view.id, schema=document_view.schema, ) except asyncio.CancelledError: pass finally: downloads_gauge.dec() messages = filter_none([progress_bar_download.message]) await self.delivery_service.telegram_client.delete_messages( request_context.chat.chat_id, messages)