async def handler(event):
builder = event.builder
result = None
query = event.text.lower()
if query == 'ping':
result = builder.article('Pong!', text='This bot works inline')
elif query == 'group':
result = builder.article(
'Move to the right group!',
text='Try moving to the [right group](t.me/TelethonChat)',
buttons=custom.Button.url('Join the group!', 't.me/TelethonChat'),
link_preview=False)
elif query in ('python', 'learn'):
result = builder.article('Resources to Learn Python',
text=GOOD_RESOURCES,
link_preview=False)
else:
m = re.match('(client|msg).(.+)', query)
if m:
text = get_docs_message(m.group(1), m.group(2))
query = markdown.parse(text)[0]
result = builder.article(query, text=text)
else:
m = re.match('ref.(.+)', query)
if m:
query = m.group(1)
text = DOCS.format(query, urllib.parse.quote(query))
result = builder.article(query, text=text)
await event.answer([result] if result else None)
def test_dump_msg_entities(self):
"""Show that entities are correctly parsed and stored"""
message = types.Message(
id=1,
to_id=types.PeerUser(321),
date=datetime.now(),
message='No entities'
)
dumper = Dumper(self.dumper_config)
fmt = BaseFormatter(dumper.conn)
# Test with no entities
await dumper.dump_message(message, 123, None, None)
dumper.commit()
assert not next(fmt.get_messages_from_context(123, order='DESC')).formatting
# Test with many entities
text, entities = markdown.parse(
'Testing message with __italic__, **bold**, inline '
'[links](https://example.com) and [mentions](@hi), '
'as well as `code` and ``pre`` blocks.'
)
entities[3] = types.MessageEntityMentionName(
entities[3].offset, entities[3].length, 123
)
message.id = 2
message.date -= timedelta(days=1)
message.message = text
message.entities = entities
await dumper.dump_message(message, 123, None, None)
dumper.commit()
msg = next(fmt.get_messages_from_context(123, order='ASC'))
assert utils.decode_msg_entities(msg.formatting) == message.entities
def test_entities_together():
"""
Test that an entity followed immediately by a different one behaves well.
"""
original = '**⚙️**__Settings__'
stripped = '⚙️Settings'
text, entities = markdown.parse(original)
assert text == stripped
assert entities == [MessageEntityBold(0, 2), MessageEntityItalic(2, 8)]
text = markdown.unparse(text, entities)
assert text == original
def test_offset_at_emoji():
"""
Tests that an entity starting at a emoji preserves the emoji.
"""
text = 'Hi\n👉 See example'
entities = [
MessageEntityBold(0, 2),
MessageEntityItalic(3, 2),
MessageEntityBold(10, 7)
]
parsed = '**Hi**\n__👉__ See **example**'
assert markdown.parse(parsed) == (text, entities)
assert markdown.unparse(text, entities) == parsed
async def handler(event):
builder = event.builder
result = None
query = event.text.lower()
m = re.match('(client|msg).(.+)', query)
if m:
text = get_docs_message(m.group(1), m.group(2))
query = markdown.parse(text)[0]
result = builder.article(query, text=text)
else:
m = re.match('ref.(.+)', query)
if m:
query = m.group(1)
text = DOCS.format(query, urllib.parse.quote(query))
result = builder.article(query, text=text)
await event.answer([result] if result else None)
async def answer(self,
*args,
log: str or Tuple[str, str] = None,
reply: bool = False,
**kwargs) -> Union[custom.Message, List[custom.Message]]:
"""Custom bound method for the Message object"""
message_out = None
message = await self.client.get_messages(self.chat_id, ids=self.id)
reply_to = self.reply_to_msg_id or self.id
if len(args) == 1 and isinstance(args[0], str):
is_reply = reply or kwargs.get('reply_to', False)
text = args[0]
msg, msg_entities = markdown.parse(text)
if len(msg) <= MAXLIM:
if (not (message and message.out) or is_reply or self.fwd_from or
(self.media
and not isinstance(self.media, types.MessageMediaWebPage))):
kwargs.setdefault('reply_to', reply_to)
try:
kwargs.setdefault('silent', True)
message_out = await self.respond(text, **kwargs)
except Exception as e:
LOGGER.exception(e)
else:
if len(msg_entities) > 100:
messages = await _resolve_entities(msg, msg_entities)
chunks = [markdown.unparse(t, e) for t, e in messages]
message_out = []
try:
first_msg = await self.edit(chunks[0], **kwargs)
except errors.rpcerrorlist.MessageIdInvalidError:
first_msg = await self.respond(chunks[0], **kwargs)
except Exception as e:
LOGGER.exception(e)
message_out.append(first_msg)
for t in chunks[1:]:
try:
kwargs.setdefault('silent', True)
sent = await self.respond(t, **kwargs)
message_out.append(sent)
except Exception as e:
LOGGER.exception(e)
else:
try:
message_out = await self.edit(text, **kwargs)
except errors.rpcerrorlist.MessageIdInvalidError:
message_out = await self.respond(text, **kwargs)
except Exception as e:
LOGGER.exception(e)
else:
if (message and message.out
and not (message.fwd_from or message.media)):
try:
await self.edit("`Output exceeded the limit.`")
except errors.rpcerrorlist.MessageIdInvalidError:
await self.respond("`Output exceeded the limit.`")
except Exception as e:
LOGGER.exception(e)
kwargs.setdefault('reply_to', reply_to)
output = io.BytesIO(msg.strip().encode())
output.name = "output.txt"
try:
kwargs.setdefault('silent', True)
message_out = await self.respond(file=output, **kwargs)
output.close()
except Exception as e:
output.close()
LOGGER.exception(e)
else:
kwargs.setdefault('reply_to', reply_to)
try:
kwargs.setdefault('silent', True)
message_out = await self.respond(*args, **kwargs)
except Exception as e:
LOGGER.exception(e)
if log:
if isinstance(log, tuple):
command, extra = log
text = f"**USERBOT LOG** #{command}"
if extra:
text += f"\n{extra}"
else:
text = f"**USERBOT LOG** `Executed command:` #{log}"
if self.client.logger:
logger_group = self.client.config['userbot'].getint(
'logger_group_id', False)
entity = False
try:
entity = await self.client.get_input_entity(logger_group)
except TypeError:
LOGGER.info("Your logger group ID is unsupported")
except ValueError:
LOGGER.info("Your logger group ID cannot be found")
except Exception as e:
LOGGER.exception(e)
if entity:
message, msg_entities = markdown.parse(text)
if len(message) <= MAXLIM and len(msg_entities) < 100:
messages = [(message, msg_entities)]
else:
messages = await _resolve_entities(message, msg_entities)
for text, entities in messages:
try:
await self.client(
functions.messages.SendMessageRequest(
peer=entity,
message=text,
no_webpage=True,
silent=True,
entities=entities))
await asyncio.sleep(2)
except Exception as e:
print("Report this error to the support group.")
LOGGER.exception(e)
return message_out