def test_de_json_required_args(self, bot, user):
json_dict = {'user': user.to_dict(), 'status': self.status}
chat_member = ChatMember.de_json(json_dict, bot)
assert chat_member.user == user
assert chat_member.status == self.status
def test_de_json_all_args(self, bot, user):
time = datetime.datetime.now()
json_dict = {
'user': user.to_dict(),
'status': self.status,
'until_date': to_timestamp(time),
'can_be_edited': False,
'can_change_info': True,
'can_post_messages': False,
'can_edit_messages': True,
'can_delete_messages': True,
'can_invite_users': False,
'can_restrict_members': True,
'can_pin_messages': False,
'can_promote_members': True,
'can_send_messages': False,
'can_send_media_messages': True,
'can_send_polls': False,
'can_send_other_messages': True,
'can_add_web_page_previews': False
}
chat_member = ChatMember.de_json(json_dict, bot)
assert chat_member.user == user
assert chat_member.status == self.status
assert chat_member.can_be_edited is False
assert chat_member.can_change_info is True
assert chat_member.can_post_messages is False
assert chat_member.can_edit_messages is True
assert chat_member.can_delete_messages is True
assert chat_member.can_invite_users is False
assert chat_member.can_restrict_members is True
assert chat_member.can_pin_messages is False
assert chat_member.can_promote_members is True
assert chat_member.can_send_messages is False
assert chat_member.can_send_media_messages is True
assert chat_member.can_send_polls is False
assert chat_member.can_send_other_messages is True
assert chat_member.can_add_web_page_previews is False
def test_de_json_all_args(self, bot, user):
time = datetime.datetime.now()
json_dict = {'user': user.to_dict(),
'status': self.status,
'until_date': to_timestamp(time),
'can_be_edited': False,
'can_change_info': True,
'can_post_messages': False,
'can_edit_messages': True,
'can_delete_messages': True,
'can_invite_users': False,
'can_restrict_members': True,
'can_pin_messages': False,
'can_promote_members': True,
'can_send_messages': False,
'can_send_media_messages': True,
'can_send_other_messages': False,
'can_add_web_page_previews': True}
chat_member = ChatMember.de_json(json_dict, bot)
assert chat_member.user == user
assert chat_member.status == self.status
assert chat_member.can_be_edited is False
assert chat_member.can_change_info is True
assert chat_member.can_post_messages is False
assert chat_member.can_edit_messages is True
assert chat_member.can_delete_messages is True
assert chat_member.can_invite_users is False
assert chat_member.can_restrict_members is True
assert chat_member.can_pin_messages is False
assert chat_member.can_promote_members is True
assert chat_member.can_send_messages is False
assert chat_member.can_send_media_messages is True
assert chat_member.can_send_other_messages is False
assert chat_member.can_add_web_page_previews is True
ChatMember,
ChatJoinRequest,
)
from telegram.poll import PollAnswer
from telegram.utils.helpers import from_timestamp
message = Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Text')
chat_member_updated = ChatMemberUpdated(
Chat(1, 'chat'),
User(1, '', False),
from_timestamp(int(time.time())),
ChatMember(User(1, '', False), ChatMember.CREATOR),
ChatMember(User(1, '', False), ChatMember.CREATOR),
)
chat_join_request = ChatJoinRequest(
chat=Chat(1, Chat.SUPERGROUP),
from_user=User(1, 'first_name', False),
date=from_timestamp(int(time.time())),
bio='bio',
)
params = [
{
'message': message
},
{
def chat_member(user):
return ChatMember(user, TestChatMember.status)
def test_de_json_all_args(self, bot, chat_member_class_and_status, user):
cls = chat_member_class_and_status[0]
status = chat_member_class_and_status[1]
time = datetime.datetime.utcnow()
json_dict = {
'user': user.to_dict(),
'status': status,
'custom_title': 'PTB',
'is_anonymous': True,
'until_date': to_timestamp(time),
'can_be_edited': False,
'can_change_info': True,
'can_post_messages': False,
'can_edit_messages': True,
'can_delete_messages': True,
'can_invite_users': False,
'can_restrict_members': True,
'can_pin_messages': False,
'can_promote_members': True,
'can_send_messages': False,
'can_send_media_messages': True,
'can_send_polls': False,
'can_send_other_messages': True,
'can_add_web_page_previews': False,
'can_manage_chat': True,
'can_manage_voice_chats': True,
}
chat_member_type = ChatMember.de_json(json_dict, bot)
assert isinstance(chat_member_type, ChatMember)
assert isinstance(chat_member_type, cls)
assert chat_member_type.user == user
assert chat_member_type.status == status
if chat_member_type.custom_title is not None:
assert chat_member_type.custom_title == 'PTB'
assert type(chat_member_type) in {ChatMemberOwner, ChatMemberAdministrator}
if chat_member_type.is_anonymous is not None:
assert chat_member_type.is_anonymous is True
assert type(chat_member_type) in {ChatMemberOwner, ChatMemberAdministrator}
if chat_member_type.until_date is not None:
assert type(chat_member_type) in {ChatMemberBanned, ChatMemberRestricted}
if chat_member_type.can_be_edited is not None:
assert chat_member_type.can_be_edited is False
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_change_info is not None:
assert chat_member_type.can_change_info is True
assert type(chat_member_type) in {ChatMemberAdministrator, ChatMemberRestricted}
if chat_member_type.can_post_messages is not None:
assert chat_member_type.can_post_messages is False
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_edit_messages is not None:
assert chat_member_type.can_edit_messages is True
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_delete_messages is not None:
assert chat_member_type.can_delete_messages is True
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_invite_users is not None:
assert chat_member_type.can_invite_users is False
assert type(chat_member_type) in {ChatMemberAdministrator, ChatMemberRestricted}
if chat_member_type.can_restrict_members is not None:
assert chat_member_type.can_restrict_members is True
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_pin_messages is not None:
assert chat_member_type.can_pin_messages is False
assert type(chat_member_type) in {ChatMemberAdministrator, ChatMemberRestricted}
if chat_member_type.can_promote_members is not None:
assert chat_member_type.can_promote_members is True
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_send_messages is not None:
assert chat_member_type.can_send_messages is False
assert type(chat_member_type) == ChatMemberRestricted
if chat_member_type.can_send_media_messages is not None:
assert chat_member_type.can_send_media_messages is True
assert type(chat_member_type) == ChatMemberRestricted
if chat_member_type.can_send_polls is not None:
assert chat_member_type.can_send_polls is False
assert type(chat_member_type) == ChatMemberRestricted
if chat_member_type.can_send_other_messages is not None:
assert chat_member_type.can_send_other_messages is True
assert type(chat_member_type) == ChatMemberRestricted
if chat_member_type.can_add_web_page_previews is not None:
assert chat_member_type.can_add_web_page_previews is False
assert type(chat_member_type) == ChatMemberRestricted
if chat_member_type.can_manage_chat is not None:
assert chat_member_type.can_manage_chat is True
assert type(chat_member_type) == ChatMemberAdministrator
if chat_member_type.can_manage_voice_chats is not None:
assert chat_member_type.can_manage_voice_chats is True
assert type(chat_member_type) == ChatMemberAdministrator
def test_de_json_invalid_status(self, bot, user):
json_dict = {'status': 'invalid', 'user': user.to_dict()}
chat_member_type = ChatMember.de_json(json_dict, bot)
assert type(chat_member_type) is ChatMember
assert chat_member_type.status == 'invalid'
def bite(update, context):
# Схватываем всех админов и помещаем в list
admins = context.bot.get_chat_administrators(update.message.chat.id)
# Определяем, есть ли среди отправителя и получателя админы
sender = ChatMember(update.message.from_user.id, 'unknown')
for i in range(0, len(admins)):
if (sender.user == admins[i].user.id):
sender.status = 'administrator'
if (sender.status != 'administrator'):
sender.status = 'member'
recipient = ChatMember(
update.effective_message.reply_to_message.from_user.id, 'unknown')
for i in range(0, len(admins)):
if (recipient.user == admins[i].user.id):
recipient.status = 'administrator'
if (recipient.status != 'administrator'):
recipient.status = 'member'
# Обрабатываем сам кусь
if (update.effective_message.text.lower() == 'кусь'):
# Подбрасываем монетку
coin = random.randint(1, 100)
file_num = random.randint(1, 5)
# admin vs admin
if (sender.status == recipient.status == 'administrator'):
update.message.reply_photo(photo=open('special/love.jpg', 'rb'))
update.message.reply_text(
"Воу-воу, битва админов. Я на такое не подписывался!")
return
# admin vs member
if (sender.status == 'administrator' and coin % 2 == 0):
update.message.reply_photo(photo=open('special/armored.jpg', 'rb'))
update.message.reply_text(
"Админу @" + str(update.message.from_user.username) +
" не удалось укусить пользователя @" +
str(update.effective_message.reply_to_message.from_user.
username) + "!")
return
elif (recipient.status != 'administrator'
and sender.status == 'administrator'):
context.bot.restrict_chat_member(
update.message.chat.id,
update.effective_message.reply_to_message.from_user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=time() + 30)
update.message.reply_photo(
photo=open('kus\'/kus\'' + str(file_num) + '.jpg', 'rb'))
update.message.reply_text(
"Админ @" + str(update.message.from_user.username) +
" не оставил шансов пользователю @" +
str(update.effective_message.reply_to_message.from_user.
username) + "!")
return
# member vs admin
if (recipient.status == 'administrator'):
context.bot.restrict_chat_member(
update.message.chat.id,
update.message.from_user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=time() + 30)
update.message.reply_photo(
photo=open('antikus\'/antikus\'' + str(file_num) +
'.jpg', 'rb'))
update.message.reply_text("Слабоумие и отвага. Админ @" + str(
update.effective_message.reply_to_message.from_user.username) +
" даже не почувствовал пользователя @" +
str(update.message.from_user.username) +
" !")
return
# member vs member
if (coin % 2 == 0 and update.message.from_user):
context.bot.restrict_chat_member(
update.message.chat.id,
update.message.from_user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=time() + 30)
update.message.reply_photo(
photo=open('antikus\'/antikus\'' + str(file_num) +
'.jpg', 'rb'))
update.message.reply_text(
"Пользователь @" + str(update.message.from_user.username) +
" попробовал укусить @" +
str(update.effective_message.reply_to_message.from_user.
username) + ", но тот увернулся и нанес антикусь!")
else:
context.bot.restrict_chat_member(
update.message.chat.id,
update.effective_message.reply_to_message.from_user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=time() + 30)
update.message.reply_photo(
photo=open('kus\'/kus\'' + str(file_num) + '.jpg', 'rb'))
update.message.reply_text(
"Пользователь @" + str(update.message.from_user.username) +
" кусил @" + str(update.effective_message.reply_to_message.
from_user.username) + "!")
# Реализуем мут
st = update.effective_message.text.lower()
s = st.split()
if (s[0] == 'мут'
and (sender.status == 'administrator' or sender.user == master)
and recipient.status != 'administrator'
and recipient.user != master):
try:
t = int(s[1])
if (s[2] == 'мин'): t = t * 60
elif (s[2] == 'ч'): t = t * 3600
elif (s[2] == 'cут'): t = t * 3600 * 24
except:
update.message.reply_text("Укажи правильно время мута, котик!")
return
context.bot.restrict_chat_member(
update.message.chat.id,
update.effective_message.reply_to_message.from_user.id,
permissions=ChatPermissions(can_send_messages=False),
until_date=time() + t)
update.message.reply_text(
"@" +
str(update.effective_message.reply_to_message.from_user.username) +
" получил мут на " + s[1] + " " + s[2] + "!")
elif (s[0] == 'мут'
and sender.status == recipient.status == 'administrator'):
update.message.reply_text(
"Воу-воу, битва админов. Я на такое не подписывался!")
elif (s[0] == 'мут' and recipient.user == master):
update.message.reply_photo(photo=open('special/shield.jpg', 'rb'))
update.message.reply_text(
"РРРРРРРРРРРРРРР! За что ты так с моим хозяином?!")
elif (s[0] == 'мут'):
update.message.reply_text("Котик, не обманывай меня, ты не админ!")
# Обрабатываем анмут
if (update.effective_message.text.lower() == 'анмут'
and (sender.status == 'administrator' or sender.user == master)
and recipient.status != 'administrator'
and recipient.user != master):
context.bot.restrict_chat_member(
update.message.chat.id,
update.effective_message.reply_to_message.from_user.id,
permissions=ChatPermissions(can_send_messages=True),
until_date=0)
update.message.reply_text(
"@" +
str(update.effective_message.reply_to_message.from_user.username) +
" вновь может писать!")
elif (update.effective_message.text.lower() == 'анмут'
and sender.status == recipient.status == 'administrator'):
update.message.reply_text(
"Воу-воу, битва админов. Я на такое не подписывался!")
elif (update.effective_message.text.lower() == 'анмут'):
update.message.reply_text("Котик, не обманывай меня, ты не админ!")
# Обрабатываем бан
if (update.effective_message.text.lower() == 'бан'
and (sender.status == 'administrator' or sender.user == master)
and recipient.status != 'administrator'
and recipient.user != master):
context.bot.kick_chat_member(
update.message.chat.id,
update.effective_message.reply_to_message.from_user.id,
until_date=0)
update.message.reply_text(
"@" +
str(update.effective_message.reply_to_message.from_user.username) +
" получил бан!(")
elif (update.effective_message.text.lower() == 'бан'
and sender.status == recipient.status == 'administrator'):
update.message.reply_text(
"Воу-воу, битва админов. Я на такое не подписывался!")
elif (update.effective_message.text.lower() == 'бан'
and recipient.user == master):
update.message.reply_photo(photo=open('special/shield.jpg', 'rb'))
update.message.reply_text(
"РРРРРРРРРРРРРРР! За что ты так с моим хозяином?!")
elif (update.effective_message.text.lower() == 'бан'):
update.message.reply_text("Котик, не обманывай меня, ты не админ!")
# Обрабатываем анбан
if (update.effective_message.text.lower() == 'анбан'
and (sender.status == 'administrator' or sender.user == master)
and recipient.status != 'administrator'
and recipient.user != master):
context.bot.unban_chat_member(
update.message.chat.id,
update.effective_message.reply_to_message.from_user.id,
until_date=0)
update.message.reply_text(
"@" +
str(update.effective_message.reply_to_message.from_user.username) +
" был разбанен!)")
link = context.bot.export_chat_invite_link(update.message.chat.id)
context.bot.send_message(
update.effective_message.reply_to_message.from_user.id,
"Котик, тебя разбанили! Ссылка для возврата в чат:" + link)
elif (update.effective_message.text.lower() == 'анбан'
and sender.status == recipient.status == 'administrator'):
update.message.reply_text(
"Воу-воу, битва админов. Я на такое не подписывался!")
elif (update.effective_message.text.lower() == 'анбан'
and recipient.user == master):
update.message.reply_photo(photo=open('special/shield.jpg', 'rb'))
update.message.reply_text(
"РРРРРРРРРРРРРРР! За что ты так с моим хозяином?!")
elif (update.effective_message.text.lower() == 'анбан'):
update.message.reply_text("Котик, не обманывай меня, ты не админ!")
def new_chat_member(user):
return ChatMember(user, TestChatMemberUpdated.new_status)
def old_chat_member(user):
return ChatMember(user, TestChatMemberUpdated.old_status)
def test_de_json_invalid_status(self, chat_member_type, bot):
json_dict = {"status": "invalid", "user": CMDefaults.user.to_dict()}
chat_member_type = ChatMember.de_json(json_dict, bot)
assert type(chat_member_type) is ChatMember
assert chat_member_type.status == "invalid"
def member(*args, **kwargs):
if args[1] == 0:
return ChatMember(User(0, 'TestUser0', False), 'administrator')
if args[1] == 1:
return ChatMember(User(1, 'TestUser1', False), 'creator')
raise TelegramError('User is not a member')
def admins(*args, **kwargs):
return [
ChatMember(User(0, 'TestUser0', False), 'administrator'),
ChatMember(User(1, 'TestUser1', False), 'creator'),
]
def admins(*args, **kwargs):
return [ChatMember(User(2, 'TestUser0', False), 'administrator')]
def get_chat_administrators(self, chat_id, timeout=None, **kwargs):
return list(
map(
lambda user: ChatMember(User(1, user, False), ChatMember.
ADMINISTRATOR), self.admin_user))