def run(self):
vk_session = vk_api.VkApi(token=self.token)
self.vk = vk_session.get_api()
vk_longpoll = VkLongPoll(vk_session, wait=25)
while True:
self.__notify()
for event in vk_longpoll.check():
self.__event_handler(event)
def run(self, token):
vk_session = vk_api.VkApi(token=self.token)
vk_longpoll = VkLongPoll(vk_session, wait=25)
self.vk = vk_session.get_api()
self.osu_api = OSUApi(token)
while True:
self.save_users()
self.check_notifications()
for event in vk_longpoll.check():
self.handle_event(event)
def poll(self, handler: Callable[[Event], None]) -> None:
poll = VkLongPoll(self._vk)
while True:
try:
events = poll.check()
except ReadTimeout:
logger.warning("Poll read timeout")
continue
for event in events:
logger.debug("Received raw event: %s", event.raw)
if event := self._create_event(event):
handler(event)
class VkLongPollThread(Thread):
def __init__(self, api, period):
Thread.__init__(self, target=self.event_handler)
self.vk_met = api.get_api()
self.stop_flag = False
self.longpoll = VkLongPoll(vk=api,
mode=VkLongpollMode.GET_EXTENDED,
preload_messages=True)
self.period = period
def event_handler(self):
while (self.stop_flag == False):
try:
event_list = self.longpoll.check()
for event in event_list:
if event.type == VkEventType.MESSAGE_NEW:
msg = event.message_data
user = self.vk_met.users.get(user_id=msg['from_id'])
print(user[0]['first_name'] + ' ' +
user[0]['last_name'] + ': ' + msg['text'])
if msg['peer_id'] == 2000000182 and (
anime_set.intersection(set(msg['text'].split(
)))) != set() and msg['from_id'] != 94734732:
self.vk_met.messages.send(peer_id=msg['peer_id'],
message='Привет =)',
random_id=randint(
0,
0xFFFFFFFFFFFFFFFF))
if (joke_set.intersection(set(msg['text'].split()))
) != set() and msg['from_id'] != 94734732:
url = 'https://bash.im/random/'
r = requests.get(url)
i = r.text.find('<div class="text">')
k = r.text.find('</div>', i)
self.vk_met.messages.send(
peer_id=msg['peer_id'],
message=
'Анекдот:\n------------------------------------------------\n'
+ html2text.html2text(r.text[i:k + 6]) +
'\n------------------------------------------------',
random_id=randint(0, 0xFFFFFFFFFFFFFFFF))
except:
print('error occured')
sleep(self.period)
def stop(self):
self.stop_flag = True
class VkontakteClass(IMessenger):
def __init__(self, token: str):
super().__init__(token)
self.__session = vk_api.VkApi(token=token)
self.__vkApi = self.__session.get_api()
self.__longpoll = VkLongPoll(self.__session)
def sendMessage(self, userId, message: str):
self.__vkApi.messages.send(user_id=userId, message=message)
def getLastMessages(self):
result = {}
events = self.__longpoll.check()
for event in events:
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
if event.user_id in result:
result[event.user_id].append(event.text)
else:
result[event.user_id] = [event.text]
return result
class Game():
def __init__(self):
logger.logger()
logger.log("Initialization...")
str_const.set_fracs_list()
vk_session = vk_api.VkApi(token=vk_token.token)
self.vk = vk_session.get_api()
self.longpoll = VkLongPoll(vk_session, wait=const.wait)
self.is_running = True
#self.counter = 0
self.player = PlayerManager()
self.database = LiteDB()
self.quest = Quest()
logger.log("Initialization complete!")
def process(self):
while self.is_running:
self.quest.check_quest(self.vk, self.database)
#logger.log("Begin check")
events = self.longpoll.check()
#logger.log("End check")
if len(events) != 0:
for i in range(len(events)):
event = events[i]
if event:
self._proc_event(event)
def _proc_event(self, event):
if not event.from_me:
if event.type == VkEventType.MESSAGE_NEW and event.text:
random.seed()
#---------------------------------------------------------------stop
self.is_running = self.player.stop(self.vk, event)
#---------------------------------------------------------------stop
self.player.event_handling(self.vk, event, self.database,
self.quest)
class QVkMessenger(QMessenger):
"""VC (vc.com) connector for qbot"""
MAX_MESSAGE_LENGTH = 4096
MAX_MESSAGE_LENGTH_FOR_LOG = 80
def __init__(self, **config):
QMessenger.__init__(self, VERSION=VERSION, **config)
self.dvd_group_id = config['group_id']
self.group_token = config['group_token']
self.vk_session = vk_api.VkApi(token=self.group_token)
self.vk = self.vk_session.get_api()
self.vk_user = vk_api.VkApi(self.vk_session)
self.lPoll = VkLongPoll(self.vk_session)
self.errorTimeout = 5
self.logger.debug('Init completed')
def getMessages(self):
events = self.lPoll.check()
res = {'ok': True, 'messages': [], 'status': 'OK'}
for event in events:
#self.logger.debug("New event: type=%s, user_id=%s,text=%s,to_me='%s', from_me='%s', Attachments: %s" % (event.type, event.user_id, event.text, event.to_me, event.from_me, event.attachments))
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
self.logger.debug(
"New event: type=%s, user_id=%s,text=%s,to_me='%s', from_me='%s', Attachments: %s"
% (event.type, event.user_id, event.text, event.to_me,
event.from_me, event.attachments))
files = []
caption = None
try:
text = event.text
except Exception as err:
self.logger.warning('Read message text failed: %s' % err)
text = None
if len(event.attachments) > 0:
msg = self.vk.messages.getById(
message_ids=event.message_id)
atch_list = msg['items'][0]['attachments']
for f in atch_list:
type = f['type']
url = f[type]['url']
files.append({
'file_name': f[type]['title'],
'file_size': f[type]['size'],
'file_id': f[type]['id'],
'file_type': type,
'url': url
})
message = {'text': text, 'caption': caption, 'files': files, 'user_id': event.user_id, 'message_id': str(event.message_id),\
'message_time': str(event.datetime), 'replyto': event.user_id, 'message':event}
res['messages'].append(message)
res['status'] = 'OK: %s messages' % len(res['messages'])
return res
def get_file(self, file, path=None):
if not path:
path = self.savedir
fname = "%s/%s" % (os.path.normpath(path), file['file_name'])
resp = requests.get(file['url'])
if resp.ok:
fil = open(fname, 'wb')
sz = fil.write(resp.content)
fil.close()
res = "%s: %s/%s bytes" % (fname, sz, file['file_size'])
self.logger.debug(res)
else:
res = '%s - error: %s' % (fname, resp.json())
self.logger.error(res)
return res
def reply(self, msg, originalCommand):
return self.sendMessage(msg, originalCommand['user_id'])
def sendMessage(self, msg, to):
i = 0
self.sendStatusText = 'OK'
try:
while i <= len(msg):
j = i + self.MAX_MESSAGE_LENGTH if i + self.MAX_MESSAGE_LENGTH <= len(
msg) else len(msg)
self.vk.messages.send(user_id=to, message=msg[i:j])
i += self.MAX_MESSAGE_LENGTH
except Exception as err:
self.sendStatusText = "Send message failed: %s" % (err)
self.logger.error(self.sendStatusText)
self.logger.debug('Message sent: %s' %
(msg[0:self.MAX_MESSAGE_LENGTH_FOR_LOG]))
class Bot(object):
def __init__(self, vk_session):
self.logger_root = logging.getLogger("bot")
self.logger_root.info("Bot was created")
self.logger_messages = logging.getLogger("messages")
self.vk_session = vk_session
self.vk = self.vk_session.get_api()
self.vk_methods = VkApiMethod(self.vk)
self.longpoll = VkLongPoll(self.vk_session)
self.database = UsersDatabase("containers/database.sqlite")
self.months = [
"января", "февраля", "марта", "апреля", "мая", "июня", "июля",
"августа", "сентября", "октября", "ноября", "декабря"
]
self.shifts = {"Первая смена": "1", "Вторая смена": "2"}
self.irrelevant_data_message = "Нет актуальной информации. Попробуй " \
"проверить позже, она обновляется в " \
"6 и 11 часов до полудня."
self.help_message = "Хочешь воспользоваться моими командами? Выбери " \
"одну из них при помощи клавиатуры или напиши " \
'мне "список команд".'
self.list_of_commands = "Напиши мне команду, чтобы " \
"воспользоваться ей. \n" \
"Cписок и описание моих команд:\n" \
'"Получать уведомления"' \
"- я предложу вам выбрать смену, в " \
"которой вы обучаетесь, чтобы информировать " \
"вас об актировках при появлении информации " \
"о них.\n" \
'"Больше не получать"' \
"- я больше не буду присылать вам " \
"уведомления 😢😢😢\n" \
'"Актуальная информация"' \
"- я сообщу вам самую свежую информацию об " \
"актировках сегодня для обоих смен."
self.last_update = []
self.messages_callback = {
"Получать уведомления об актировках": self.get_shift,
"Получать уведомления": self.get_shift,
"Первая смена": self.add_to_inform,
"Вторая смена": self.add_to_inform,
"Больше не получать уведомления": self.exclude_from_informing,
"Больше не получать": self.exclude_from_informing,
"Актуальная информация": self.inform_event
}
self.messages_answers = {"Список команд": self.list_of_commands}
self.messages_callback = {
self.text_processing(key): value
for key, value in self.messages_callback.items()
}
self.messages_answers = {
self.text_processing(key): value
for key, value in self.messages_answers.items()
}
def listen(self):
"""
Checks every event which bot can get, answers on messages
"""
for event in self.longpoll.check():
if event.type == VkEventType.MESSAGE_NEW and event.text \
and event.to_me:
self.logger_messages.info("New message from %s" %
str(event.peer_id))
text = self.text_processing(event.text)
if text in self.messages_callback:
self.messages_callback[text](event)
elif text in self.messages_answers:
self.send_message(event, self.messages_answers[text])
else:
self.help(event)
def send_message(self, event, text):
try:
self.vk.messages.send(peer_id=event.peer_id,
message=text,
random_id=self.get_random_id())
except Exception as exception:
self.emergency(exception)
def send_keyboard(self, event, message_, keyboard_):
try:
self.vk.messages.send(peer_id=event.peer_id,
message=message_,
keyboard=keyboard_,
random_id=self.get_random_id())
except Exception as exception:
self.emergency(exception)
def help(self, event):
"""
Sends user keyboard with main commands.
"""
keyboard_ = VkKeyboard(one_time=False)
keyboard_.add_button("Получать уведомления об актировках",
color=VkKeyboardColor.PRIMARY)
keyboard_.add_line()
keyboard_.add_button("Больше не получать уведомления")
keyboard_.add_line()
keyboard_.add_button("Актуальная информация",
color=VkKeyboardColor.PRIMARY)
self.send_keyboard(event, self.help_message, keyboard_.get_keyboard())
def get_shift(self, event):
keyboard_ = VkKeyboard(one_time=True)
keyboard_.add_button("Первая смена")
keyboard_.add_button("Вторая смена", color=VkKeyboardColor.PRIMARY)
self.send_keyboard(event, "Выбери смену, в которой ты учишься",
keyboard_.get_keyboard())
def add_to_inform(self, event):
"""
Adds chat's or user's id to the database.
"""
self.logger_messages.info("Attempt. Add user to inform list")
success_message = """Теперь вы будете получать уведомления об
актировках."""
decline_message = """Вы уже получаете уведомления об
актировках."""
shift = int(self.shifts[event.text])
user_subs = self.database.get_user(event.peer_id)
if not user_subs:
self.database.add_user(event.peer_id)
user_subs = [False, False]
if not user_subs[shift - 1]:
self.logger_messages.info("The attempt was successful.")
self.database.subscribe(event.peer_id, shift)
self.send_message(event, success_message)
else:
self.logger_messages.info("Declined.")
self.send_message(event, decline_message)
def inform(self, update, shift):
"""
Sends information message to every user/chat who/which had subscribed.
"""
self.logger_root.info("Informing %s shift." % str(shift))
if shift:
date = update[0]
date[1] = self.months[date[1] - 1]
date = " ".join([str(i) for i in date])
for user in self.database.get_all():
user = {"id": user[0], 1: user[1], 2: user[2]}
if user[shift]:
# Prevents sending message to user, who has banned bot
try:
self.vk.messages.send(peer_id=user["id"],
message=date + "\n" +
update[shift],
random_id=self.get_random_id())
except vk_api.ApiError as exception:
self.logger_root.error(msg="Error: %s\n"
"User was excluded "
"from informing" % e.__str__())
# If user has banned bot, deletes his if from storage
self.database.delete(user["id"])
continue
def inform_event(self, event):
"""
Sends information message for one certain user/chat.
"""
self.logger_messages.info("Information was requested")
date = self.last_update[0] if self.last_update else False
flag = False
if [time.localtime()[2], time.localtime()[1]] == date:
flag = True
# If information is relevant
if flag:
"""
Message:
1. <1st shift text>
2. <2nd shift text>
"""
message = self.last_update[1] + "\n" + self.last_update[2]
self.send_message(event, message)
else:
self.send_message(event, self.irrelevant_data_message)
def exclude_from_informing(self, event):
"""
Delete chat's or user's id from container file.
"""
self.logger_messages.info("User was excluded from informing")
success_message = "Вы больше не будете получать уведомления об " \
"актировках."
decline_message = "Вы и так не получаете уведомления."
if self.database.get_user(event.peer_id):
self.database.delete(event.peer_id)
self.send_message(event, success_message)
else:
self.send_message(event, decline_message)
def emergency(self, exception):
"""
Sends emergency message to the creator.
Also prints it and writes to the file
"""
self.logger_root.error(
logging.exception(
exception=exception,
msg=" ".join([type(exception).__name__,
exception.__str__()])))
self.vk.messages.send(
user_id=admin_id,
message="Помоги своему чаду! Всё сломалось! "
"Вот тип ошибки: "
"{err_type}\n Вот сообщение ошибки:{err_msg}".format(
err_type=type(exception).__name__,
err_msg=exception.__str__()),
random_id=self.get_random_id())
@staticmethod
def get_random_id():
return randrange(0, 10**6)
@staticmethod
def key_by_value(dictionary, value):
"""
If the dictionary contains two and more keys linked with given value,
function returns first key.
:return: key
"""
return list(dictionary.keys())[list(dictionary.values()).index(value)]
@staticmethod
def text_processing(text):
"""
Deletes spaces and punctuation marks from given text and
:return: processed text
"""
punctuation_marks = [".", ",", "-", "_", "!", "?", ";", ":", "'", '"']
text = text.lower()
# Delete spaces from lowercase text
text = text.replace(" ", "")
for mark in punctuation_marks:
text = text.replace(mark, "")
return text
class Bot(object):
def __init__(self, vk_session):
self.vk_session = vk_session
self.vk = self.vk_session.get_api()
self.vk_methods = VkApiMethod(self.vk_session)
self.longpoll = VkLongPoll(self.vk_session)
self.messages_callback = {
"мои напоминания": self.show_timetable,
"напомнить": self.plan_an_event
}
self.messages_answers = {}
self.unknown_message = "Извини, я тебя не понимаю. Напиши мне" \
"'мои напоминания' или 'напомнить'"
self.messages_callback = {
process_text(key): value
for key, value in self.messages_callback.items()
}
self.messages_answers = {
process_text(key): value
for key, value in self.messages_answers.items()
}
self.events_to_plan = []
self.event_pattern = {
"peer_id": False,
"time": False,
"message_text": False
}
def listen(self):
"""Listens for events (incoming messages).
"""
for event in self.longpoll.check():
if event.type == VkEventType.MESSAGE_NEW and event.text \
and event.to_me:
if process_text(event.text) in self.messages_answers:
self.send_message(
event.peer_id,
self.messages_answers[process_text(event.text)])
elif process_text(event.text) in self.messages_callback:
self.messages_callback[process_text(event.text)]()
else:
self.send_message(event.peer_id, self.unknown_message)
def send_message(self, peer_id, msg_text):
"""Sends text message to user.
"""
try:
self.vk.messages.send(peer_id=peer_id,
message=msg_text,
random_id=randrange(0, 10**6))
except Exception as exception:
self.emergency(exception)
def plan_an_event(self, peer_id, message):
"""TODO plan: look at notebook"""
for event in self.events_to_plan:
if peer_id in event:
break
else:
self.events_to_plan.append(copy(self.event_pattern))
self.events_to_plan[-1]["peer_id"] = peer_id
def add_event_to_timetable(self, time_, message):
pass
def show_timetable(self):
pass
def emergency(self, exception):
"""Shows, that an error was raised. Sends administrator a message,
saves exception description to logs.
"""
# TODO logger, admin id
self.send_message(
admin_id, "Всё сломалось! "
"Вот тип ошибки: "
"{err_type}\n Вот сообщение ошибки:{err_msg}".format(
err_type=type(exception).__name__,
err_msg=exception.__str__()))
def play(user_id):
c.execute("SELECT user_id FROM play WHERE user_id = %d" % user_id)
result88 = c.fetchone()
return result88[0]
while True:
for event in longpoll.check():
if event.type == VkEventType.MESSAGE_NEW and event.text and event.to_me :
if not check_if_exists(event.user_id):
register_new_user(event.user_id)
if event.text.lower() == "начать":
vk.messages.send(
user_id=event.user_id,
message="Привет!\nХочешь ли ты получать уведомления❓",
keyboard=open("uesorno.json", "r", encoding="UTF-8").read(),
random_id=random_id()
)
