def _send_photo_path(vk, id, text, photo_path, delete=True, keyboard=None):
upload = VkUpload(vk)
uploaded = upload.photo_messages(photo_path)
if path.exists(photo_path) and delete:
os.remove(photo_path)
photo = 'photo' + str(uploaded[0]['owner_id']) + '_' + str(uploaded[0]['id'])
send_message({"vk": vk, "id": id, "message": text, "sleep_time": 0, "attachment": photo, "keyboard": keyboard})
def __init__(self, token: str, group_id: int, testers=None):
"""
основной класс бота
:param token: токен группы со всеми разрешениями
:param group_id: id группы к которой привязн токен
:param testers: список из id тестеров
"""
self.group_id = group_id
self.testers = testers
self.vk_session = vk_api.VkApi(token=token,
api_version='5.85',
scope='MESSAGE, DOCS, PHOTOS, OFFLINE')
self.upload = VkUpload(self.vk_session) # self.vk_session_me
self.longpoll = VkBotLongPoll(self.vk_session, self.group_id, wait=25)
self.vk = self.vk_session.get_api()
self.cmd_keyboard = self.c_keyboard(list(list_cmd.keys()))
self.exit_keyboard = self.c_keyboard(list('выйти'))
self.first_run = True
self.outgoing_mess_queue = Queue()
class Vk(VkApiGroup):
vk = None
def __init__(self, token):
super().__init__(token=token)
# self.method = VkApiMethod(self)
self.upload = VkUpload(self)
def get_long_poll(self, token):
return self.method(Methods.GET_LP, {'access_token': token})
def send_message(self, message: Message):
# @debug m = message.dict()
return self.method(Methods.SEND, message.dict())
def upload_message_document(self, filename: str, peer_id):
return self.upload.document_message([filename],
'video',
peer_id=peer_id)
def upload_message_photo(self, filename: str, peer_id):
return self.upload.photo_messages([filename], peer_id=peer_id)
@staticmethod
def str_dict(dictionary):
result = ''
for i in dictionary:
result += str(i) + ','
result = result[:len(result) - 1]
return result
def upload_photo(vk, photo):
upload = VkUpload(vk)
response = upload.photo_messages(photo)[0]
owner_id = response['owner_id']
photo_id = response['id']
access_key = response['access_key']
return owner_id, photo_id, access_key
def send_file(doc, id):
upload = VkUpload(vk_session)
up_info = upload.document_message(doc, '', 'logs', '288345074')
d = f'doc{up_info["doc"]["owner_id"]}_{up_info["doc"]["id"]}'
vk.messages.send(
peer_id=id,
random_id=get_random_id(),
message=
f'Screen ID: {ID} | Time: {datetime.strftime(datetime.now(), "%H:%M %d.%m ")}',
attachment=d,
)
def __init__(self):
self._auth_consts = json_handler.auth_constants
self._vk_session = VkApi(
token=self._auth_consts['api_token'],
app_id=self._auth_consts['app_id'],
client_secret=self._auth_consts['client_secret'])
self._vk_api = self._vk_session.get_api()
self._vk_upload = VkUpload(self._vk_session)
self._kernel = Kernel()
self._picture_dir = os.environ[
'BISMARCK_HOME'] + os.sep + "pictures" + os.sep
def photo_msg(self,
peer_id,
path_to_photo,
message: str = None,
many=False):
# TODO переделать совместно с созданием фоток
upload = VkUpload(self.__vk_api)
resp = upload.photo_messages(peer_id=0, photos=path_to_photo)
self.__vk_api.messages.send(
user_ids=peer_id,
attachment=
f"photo{resp[0]['owner_id']}_{resp[0]['id']}_{resp[0]['access_key']}",
message=message,
random_id=get_random_id())
def open_file(self, event, args):
""" Отправляет файл (только текстовый или графический) """
text_formats = ['txt', 'json', 'rtf', 'json', 'ui', 'py']
image_formats = ['png', 'jpeg', 'jpg', 'gif', 'bmp']
filepath = args[0]
if len(args) == 3:
x = int(args[1]) - 1
y = x + 1
elif len(args) == 4:
x = int(args[1]) - 1
y = int(args[2]) - 1
elif len(args) == 2:
x = 0
y = 20
else:
raise ArgumentCountError
if filepath[1:3] != ':/':
filepath = self.default_filepath + filepath
if os.path.isfile(filepath):
if filepath.split('.')[1] in text_formats:
with open(filepath, 'r') as file:
text = file.readlines()
vk.messages.send(user_id=event.obj.message['from_id'],
message=' '.join(text[x:y]),
random_id=random.randint(0, 2 ** 64))
elif filepath.split('.')[1] in image_formats:
upload = VkUpload(vk)
send_photo(vk, event.obj.message['from_id'],
*upload_photo(upload, filepath))
else:
vk.messages.send(user_id=event.obj.message['from_id'],
message='Неправильный формат файла.',
random_id=random.randint(0, 2 ** 64))
class VkHandler(object):
_auth_consts = None
_vk_session = None
_vk_api = None
_vk_upload = None
_kernel = None
_picture_dir = None
@logger.class_construct
def __init__(self):
self._auth_consts = json_handler.auth_constants
self._vk_session = VkApi(
token=self._auth_consts['api_token'],
app_id=self._auth_consts['app_id'],
client_secret=self._auth_consts['client_secret'])
self._vk_api = self._vk_session.get_api()
self._vk_upload = VkUpload(self._vk_session)
self._kernel = Kernel()
self._picture_dir = os.environ[
'BISMARCK_HOME'] + os.sep + "pictures" + os.sep
def handler(self):
longpoll = VkLongPoll(self._vk_session)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW:
logger.debug("New message: '" + str(event.text) + "'")
if (event.from_user and not event.from_me) or \
(event.from_chat and event.text.find('id336383265') != -1) or event.from_group:
logger.info("New message: '" + str(event.text) + "'")
answer = self._kernel.talk(str(event.text),
event.from_user)
if event.from_user:
peer_id = event.user_id
elif event.from_chat:
peer_id = 2000000000 + event.chat_id
else:
peer_id = 0 - event.group_id
if isinstance(answer, tuple):
message, picture = answer
picture = self._picture_dir + picture
picture_id = self._vk_upload.photo_messages(
photos=picture)
attachment = "photo{}_{}".format(
picture_id[0]['owner_id'], picture_id[0]['id'])
self._vk_api.messages.send(peer_id=peer_id,
message=message,
random_id=randint(
0, 1000000000000000),
attachment=attachment)
else:
self._vk_api.messages.send(peer_id=peer_id,
message=answer,
random_id=randint(
0, 1000000000000000))
def day_schedule():
"""функция для формирования сегодняшнего расписания"""
im = Image.new('RGB', (200, 200), color='#CCEEFF')
font = ImageFont.truetype("arial.ttf", 14)
x = 10
y = 10
draw = ImageDraw.Draw(im)
db_sess = db_session.create_session()
user_vk_id = day_schedule_command.id
login = db_sess.query(VkUser.epos_login).filter(VkUser.vk_id == user_vk_id).first()[0]
password = db_sess.query(VkUser.epos_password).filter(VkUser.vk_id == user_vk_id).first()[0]
epos.run(login, password)
response = epos.get_schedule()
if response == 'timeout':
abort(408)
return 'Сайт ЭПОС.Школа не отвечает. Пожалуйста, повторите запрос.'
current_date = datetime.now().day
for day in response.keys(): # создание картинки с данными
if day.split(', ')[0] == str(current_date):
if response[day]['lessons']:
for lesson_id in range(len(response[day]['lessons'])):
message = response[day]['lessons'][lesson_id].split(' ')
if message[0] == 'Алгебра':
draw.text((x, y), ' '.join(message[:3]), font=font, fill='#1C0606')
draw.text((x, y + 18), ' '.join(message[3:]), font=font, fill='#1C0606')
y += 36
elif len(message) > 2:
draw.text((x, y), ' '.join(message[:2]), font=font, fill='#1C0606')
draw.text((x, y + 18), ' '.join(message[2:]), font=font, fill='#1C0606')
y += 36
else:
draw.text((x, y), ' '.join(message), font=font, fill='#1C0606')
y += 20
else:
draw.text((x, y), 'На сегодня нет расписания', font=font, fill='#1C0606')
im.save('photo.jpg')
vk_session = VkApi(token=TOKEN)
vk = vk_session.get_api()
response = VkUpload(vk).photo_messages('photo.jpg')[0]
owner_id = response['owner_id']
photo_id = response['id']
access_key = response['access_key']
attachment = f'photo{owner_id}_{photo_id}_{access_key}'
message = ''
return message, attachment
def connect(self) -> None:
self.vk_session = VkApi(token=self.__vk_key)
self.vk = self.vk_session.get_api()
self.upload = VkUpload(self.vk_session)
self.long_poll = VkLongPoll(self.vk_session)
self.weather_forecaster = WeatherForecaster(self.__weather_key, self.vk, self.upload)
self.schedule_parser = ScheduleParser(self.vk, self.upload)
print("Бот успешно подключен к чату")
def picture_send(username1, userid1):
file_path = profile_create(username1)
upload = VkUpload(vk_session)
photo = upload.photo_messages(file_path)
owner_id = photo[0]['owner_id']
photo_id = photo[0]['id']
access_key = photo[0]['access_key']
attachment = f'photo{owner_id}_{photo_id}_{access_key}'
vk_session.method(
'messages.send', {
'user_id': userid1,
'message': 'бе',
'random_id': 0,
'attachment': attachment
})
def __init__(self, token, group_id):
"""initialization bot"""
self._token = token
self.group_id = group_id
self.vk_session_bot = vk_api.VkApi(token=token)
self.long_poll = VkBotLongPoll(vk=self.vk_session_bot, group_id=group_id)
self.vk_bot = self.vk_session_bot.get_api()
self.upload = VkUpload(self.vk_bot)
print('PhosphyBot is ready')
def screenshot(self, event, args):
""" Отправляет скриншот с компьютера """
if len(args) == 1:
pyautogui.screenshot('screenshot.png')
upload = VkUpload(vk)
send_photo(vk, event.obj.message['from_id'],
*upload_photo(upload, 'screenshot.png'))
os.remove('screenshot.png')
else:
raise ArgumentCountError
def main():
vk_session = vk_api.VkApi(token=TOKEN)
longpoll = VkBotLongPoll(vk_session, '193289108')
for event in longpoll.listen():
if event.type == VkBotEventType.MESSAGE_NEW:
vk = vk_session.get_api()
upload = VkUpload(vk)
text, user_id = event.obj.message['text'], event.obj.message[
'from_id']
message = get_message(text)
print(text)
vk.messages.send(user_id=event.obj.message['from_id'],
message=message,
random_id=random.randint(0, 2**64))
def send_image(command, user_id):
if command.upper() == 'УДАРЕНИЕ' or command == '1':
with open('./data/emphasises.json', 'r') as file:
words = json.load(file)
rand_int = random.randint(0, len(words) - 1)
owner_id, photo_id = upload_photo(
VkUpload(vk.get_api()),
open('./res/emphasises/img_{}.png'.format(rand_int), 'rb'))
attachment = "photo{}_{}".format(owner_id, photo_id)
vk.method(
"messages.send", {
"peer_id": user_id,
"attachment": attachment,
"random_id": get_random_id(),
'keyboard': keyboard.get_keyboard()
})
def main():
params = parse_args()
global vk_session
vk_session = vk_api.VkApi(token=params.vk_token)
uploader = VkUpload(
vk_session) # Понадобится для загрузки своих изображений в вк
long_poll = VkBotLongPoll(vk_session, params.vk_group_id)
global current_name
current_name = params.bot_default_name
global current_human
current_human = params.human_default_name
for event in long_poll.listen():
if event.type == VkBotEventType.MESSAGE_NEW:
print(type(event.obj))
print(event.obj) # Тут хранится все инфорация о сообщении
print()
message = event.obj.message # полученное сообщение
# peer_id = message['peer_id'] # ID пользователя куда отсылать ответ
# from_id = message['from_id'] # ID пользователя который прислал сообщение
text = message['text'] # Текст сообщения
if len(text) > 0:
# изучим текст сообщения
message_tokens, token_length = parse_text(text, current_name)
if (token_length != -1):
# Было обращение к боту
if (token_length > 0): # ecть аргументы
if (message_tokens[0] == 'clusterize'):
if (token_length > 1):
clusterize(message,
uploader,
num_of_colors=int(
message_tokens[1]))
else:
clusterize(message, uploader)
elif (message_tokens[0] == 'help'):
get_help(message)
else:
answer_to(message['peer_id'])
else:
ask_what(message)
else:
answer_to(message['peer_id'])
def main():
try:
vk_session = vk_api.VkApi(token=settings.VK_ACCESS_TOKEN)
vk = vk_session.get_api()
job_queue = JobQueue(vk)
job_queue.start()
upload = VkUpload(vk_session)
long_poll = VkBotLongPoll(vk_session, settings.VK_GROUP_ID)
for event in long_poll.listen():
if event.type == VkBotEventType.MESSAGE_NEW:
handle_message(vk, event, upload, job_queue)
elif event.type == VkBotEventType.GROUP_JOIN:
utils.send_referral_input(vk, event)
elif event.type == VkBotEventType.GROUP_LEAVE:
pass
except Exception as exc:
print(exc, file=sys.stderr)
main()
import subprocess
def parse_args():
parser = argparse.ArgumentParser() # Для параметров
parser.add_argument('--vk_token', type=str, default=cfg.VK_TOKEN)
parser.add_argument('--vk_group_id', type=int, default=cfg.GROUP_ID)
return parser.parse_args()
answers = deque()
params = parse_args()
vk_session = vk_api.VkApi(token=params.vk_token)
uploader = VkUpload(
vk_session) # Понадобится для загрузки своих изображений в вк
long_poll = VkBotLongPoll(vk_session, params.vk_group_id)
def start_clustering(n_clusters, image,
answer): #PROGRESS HANDLER RUNS CLUSTERING SUBPROCESS
print(n_clusters, image, answer)
timer = time.time()
process = subprocess.Popen([
'python', '-u', 'clusterizer.py', '--n_clusters',
str(n_clusters), '--image', image, '--name',
str(answer['peer_id'])
],
stdout=subprocess.PIPE,
bufsize=1)
value = 0
class BotServerBase():
''' Базовый класс Бота '''
def __init__(self, ptoken, group_id):
self.vk_session = vk_api.VkApi(token=ptoken)
self.vk_api = self.vk_session.get_api()
self.vk_upload = VkUpload(self.vk_session)
self.longpoll = VkBotLongPoll(self.vk_session, group_id)
def run(self):
'''Основной цикл'''
print("Сервер запущен")
for event in self.longpoll.listen():
try:
self.all(event)
if event.type == VkBotEventType.MESSAGE_NEW:
self.newMessage(event)
elif event.type == VkBotEventType.MESSAGE_REPLY:
self.replyMessage(event)
elif event.type == VkBotEventType.MESSAGE_TYPING_STATE:
self.typingMessage(event)
elif event.type == VkBotEventType.GROUP_JOIN:
self.groupJoin(event)
elif event.type == VkBotEventType.GROUP_LEAVE:
self.groupLeave(event)
except Exception as e:
print(e)
######################
# Обработка сообщений
######################
def newMessage(self, event):
'''Входящее сообщение (override)'''
print('\n----------------')
print('Новое сообщение:')
print('Для бота от: {0}'.format(event.obj.from_id))
def replyMessage(self, event):
'''Отправленное сообщение (override)'''
print('\n----------------')
print('Новое сообщение:')
print('От меня для: {0}'.format(event.obj.peer_id))
def typingMessage(self, event):
'''Кто-то пишет (override)'''
print('\n----------------')
print('Печатает ', end='')
print(event.obj.from_id, end=' ')
print('для ', end='')
print(event.obj.to_id)
def groupJoin(self, event):
'''Кто-то вступил в группу (override)'''
print('\n----------------')
print(event.obj.user_id, end=' ')
print('Вступил в группу!')
def groupLeave(self, event):
'''Кто-то вышел из группу (override)'''
print('\n----------------')
print(event.obj.user_id, end=' ')
print('Покинул группу!')
def all(self, event):
'''Проявлена любая активность (override)'''
pass
######################
# Работа с VK
######################
def send_message(self, event, pmessage, pattachment=None):
'''Отправить сообщение пользователю'''
self.vk_api.messages.send(user_id=event.obj.from_id,
random_id=get_random_id(),
message=pmessage,
attachment=pattachment)
def upload_document(self, event, file, title="document", tags=None):
'''Загрузить документ'''
doc = self.vk_upload.document_message(file, title, tags,
event.obj.peer_id)
self.send_message(event, title, self.build_attachment(doc))
def build_attachment(self, uploadObject):
"Построить выражение вложенного"
typeObj = uploadObject["type"]
return "{}{}_{}".format(typeObj, uploadObject[typeObj]["owner_id"],
uploadObject[typeObj]["id"])
def get_user_info(self, event):
""" Получить информацию о пользователе в данной сессии """
return User(
self.vk_api.users.get(
user_ids=event.obj.from_id,
fields='sex, bdate, city, country, home_town')[0])
class Bot:
def __init__(self, token: str, group_id: int, testers=None):
"""
основной класс бота
:param token: токен группы со всеми разрешениями
:param group_id: id группы к которой привязн токен
:param testers: список из id тестеров
"""
self.group_id = group_id
self.testers = testers
self.vk_session = vk_api.VkApi(token=token,
api_version='5.85',
scope='MESSAGE, DOCS, PHOTOS, OFFLINE')
self.upload = VkUpload(self.vk_session) # self.vk_session_me
self.longpoll = VkBotLongPoll(self.vk_session, self.group_id, wait=25)
self.vk = self.vk_session.get_api()
self.cmd_keyboard = self.c_keyboard(list(list_cmd.keys()))
self.exit_keyboard = self.c_keyboard(list('выйти'))
self.first_run = True
self.outgoing_mess_queue = Queue()
def send(self, user_id, message, **kwargs):
self.vk.messages.send(user_id=user_id, message=message, **kwargs)
def c_keyboard(self, key_list, one_time=False):
"""
генерирует клавиатуру (из переданного списка) с 3мя кнопками в одной строке
:param key_list: список кнопок, которые хоти видеть
:param one_time: True если хотим видеть одноразовый вызов клавиатуры
:return: объект VkKeyboard для последующего вызова
"""
color = VkKeyboardColor.DEFAULT
keyboard = VkKeyboard(one_time=one_time)
len_key_list = len(key_list)
for item in key_list:
# TODO цвета как-нибудь бы передать
if item == 'выйти':
# color = VkKeyboardColor.NEGATIVE
keyboard.add_button(item,
color=VkKeyboardColor.NEGATIVE,
payload='')
else:
keyboard.add_button(item, color=color, payload='')
if (key_list.index(item) +
1) % 3 == 0 and key_list.index(item) != len_key_list - 1:
keyboard.add_line()
return keyboard
def run(self):
"""
запускает бесконечный цикл в котором слушаем сервер,
при получении инфы от сервера запускаем поток с обработчиком
:return:
"""
queue_thread = threading.Thread(
target=self.outgoing_mess_queue_handler)
queue_thread.start()
log.debug('слушаем сервер')
for event in self.longpoll.listen():
if event.type == VkBotEventType.MESSAGE_NEW and event.obj.text: # and event.to_me and event.text
text = event.obj.text
user_id = event.obj.peer_id
handler = threading.Thread(
target=self.handler_mess,
args=(user_id, text)) # event.user_id, event.text
handler.start()
log.debug('запущен поток для обработки')
time.sleep(0.05)
def start(self):
"""
команда для старта бота
при старте оповещает тестеров, что бот запустился
:return:
"""
log.debug('старт бота')
if self.testers and self.first_run:
log.debug('оповещание тестеров')
self.first_run = False
[
self.send(user_id=t_id, message='йа запустилсо ┐( ˘_˘)┌')
for t_id in self.testers
]
try:
self.run()
except Exception as e:
log.exception(e)
self.start()
def outgoing_mess_queue_handler(self):
"""
обработчик исходящих сообщений
в очередь скидываются результаты работы функции handler_mess для ответа юзеру
:return:
"""
while True:
try:
user_id, mess, attach, key_list = self.outgoing_mess_queue.get(
timeout=0.1)
except Empty:
time.sleep(0.1)
continue
# чтобы загружать файлы ВК в прикреплёнке не в функции обработчике, а в основном теле
# необходимо в аттач складывать dict('тип ВК прикрепления' = [массив ссылок на файлы, ...], ...)
if attach:
all_attach = list()
photo = 'photo'
doc = 'doc'
if photo in attach.keys():
log.debug(f'{user_id} есть фото в аттаче')
for f in attach[photo]:
data = self.upload.photo_messages(photos=f,
peer_id=user_id)[0]
log.debug(f'{user_id} загружено фото: {f}')
att = 'photo{}_{}'.format(data['owner_id'], data['id'])
all_attach.append(att)
if doc in attach.keys():
log.debug(f'{user_id} есть документ в аттаче')
for d in attach[doc]:
data = self.upload.document_message(
d, title=f'doc_{user_id}', peer_id=user_id)[0]
log.debug(f'{user_id} загружен документ: {d}')
att = 'doc{}_{}'.format(data['owner_id'], data['id'])
all_attach.append(att)
attach = all_attach
# после того как получим нормальный сформированный аттач и текст для ответа
# создадим клаву и отправим все это
keyboard = self.c_keyboard(
key_list) if key_list else self.cmd_keyboard
self.send(user_id=user_id,
message=mess,
keyboard=keyboard.get_keyboard(),
attachment=attach)
def handler_mess(self, user_id, text):
"""
обработчик входящих сообщений
в папке /command/ лежат файлы с обработчиками комманд
my_func переопределяет функцию из list_cmd
:param user_id: кто написал сообщение
:param text: текст сообщения
:return:
"""
# можно пометить сразу, что прочитали, но тогда при долгом ответе покажется, что мы зависли :)
# self.vk.messages.markAsRead(peer_id=user_id)
log.debug('запрос к БДшке')
bot = psql.get_bot_or_create(user_id,
username='',
about='',
cmd='бот',
status=' ')
# text = text.lower()
if bot.cmd != 'бот':
# если текущая команда пользователя != дефолтной, т.е. он находится в какой-то другой
# то вызываем тот обработчик, на котором он находится
log.debug(f'{user_id} текущее состояние: {bot.cmd}')
my_func = list_cmd[bot.cmd]
else:
# если у пользователя нет текущей команды (т.е. дефолтная), то смотрим какие есть у нас
if text in list_cmd.keys():
# если такая есть, то вызываем ее
log.debug(f'{user_id} вызвал команда: {text}')
my_func = list_cmd[text]
else:
# если у нас нет такой команды, то намекаем, что надо выбрать из того, что есть (дефолтная клава)
log.debug(f'{user_id} вызвал не существующую команду: {text}')
self.send(user_id=user_id,
message='выбирай',
keyboard=self.cmd_keyboard.get_keyboard())
return
my_func(user_id, text, bot, self.outgoing_mess_queue)
return
def translate(request):
if 'translate' in request:
text = request[9:]
write_msg(event.user_id, ' '.join(translate_me(text)['text']))
if 'переведи' in request:
text = request[8:]
write_msg(event.user_id, ' '.join(translate_me_rus(text)['text']))
vk = vk_api.VkApi(token=token)
vk_ses = vk.get_api()
upload = VkUpload(vk)
longpoll = VkLongPoll(vk)
commander = Commander()
ships = parseShips()
items = parseItems()
print("Бот запущен")
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW:
if event.to_me:
send_message(vk, 'peer_id', event.user_id, 'Бот печатает •••',
None, create_keyboard_main())
def __init__(self, ptoken, group_id):
self.vk_session = vk_api.VkApi(token=ptoken)
self.vk_api = self.vk_session.get_api()
self.vk_upload = VkUpload(self.vk_session)
self.longpoll = VkBotLongPoll(self.vk_session, group_id)
import vk_api
import vk
from vk_api.upload import VkUpload
from vk_api.longpoll import VkLongPoll, VkEventType
from PIL import Image, ImageDraw, ImageFont
import random
import os
from settings import token
import pymorphy2
import datetime
from threading import Timer
vk_sess = vk_api.VkApi(token=token())
longpoll = VkLongPoll(vk_sess)
api = vk.API(vk_sess)
uploader = VkUpload(vk_sess)
last_text = ''
attachments = []
not_command = False
morph = pymorphy2.MorphAnalyzer()
date_now = datetime.datetime.now()
date_need = date_now.replace(day=date_now.day + 1,
hour=5,
minute=0,
second=0,
microsecond=0)
delta_t = date_need - date_now
secs = delta_t.seconds + 1
schedule = {
def get_upload(self) -> VkUpload:
return VkUpload(self.vk)
class Main(Base):
__flags__ = {
VkEventType.MESSAGE_NEW: True,
VkEventType.MESSAGE_FLAGS_SET: False,
VkEventType.MESSAGE_EDIT: False
}
def __init__(self, event: Event):
self.disable = False
self.event = event
self.upload = VkUpload(store.bot.api)
def message_new(self):
if self.event.user_id == store.bot.user_id and self.event.from_chat:
message: str = self.event.text.lower()
if message.startswith(store.config.TriggerAddAudio):
name = message.replace(store.config.TriggerAddAudio,
"").strip()
res = store.bot.api.messages.getById(
message_ids=self.event.message_id)["items"]
get_id = None
if res:
response = res[0]
reply_message = response.get("reply_message")
fwd_messages = response.get("fwd_messages")
if reply_message:
get_id = reply_message
elif fwd_messages:
get_id = fwd_messages[0]
if get_id is not None and name:
url = GetLinkAudio(get_id)
if url:
urlretrieve(url, f"example/audios/{name}.ogg")
self.MessageDelete(self.event.message_id)
loadAudios()
return
elif message.startswith(store.config.TriggerAudio):
message = message.replace(store.config.TriggerAudio, "",
1).strip()
if message in audios:
cached = store.config.audio_cache.get(message)
if not cached:
cached = self.upload.audio_message(
f"{os.getcwd()}/example/audios/{message}.ogg",
peer_id=self.event.peer_id)
audio = cached.get("audio_message")
if audio:
store.config.audio_cache[
message] = f"doc{audio['owner_id']}_{audio['id']}_{audio['access_key']}"
store.save()
res = store.bot.api.messages.getById(
message_ids=self.event.message_id)["items"]
reply_to = None
if res:
response = res[0]
reply_message = response.get("reply_message")
if reply_message:
reply_to = reply_message['id']
self.MessagesSend(
_peer_id=self.event.peer_id,
attachment=store.config.audio_cache.get(message),
reply_to=reply_to)
self.MessageDelete(self.event.message_id)
def message_edit(self):
return
def message_delete(self):
return
def __init__(self, event: Event):
self.disable = False
self.event = event
self.upload = VkUpload(store.bot.api)
def __init__(self, token):
super().__init__(token=token)
# self.method = VkApiMethod(self)
self.upload = VkUpload(self)
characters = {}
#Тут храняться монстры для каждого игрока
mobs = {}
# Состояния
state = {}
global condition
condition = {}
# Init vk_api
vk_session = VkApi(token=vkToken)
longpoll = VkBotLongPoll(vk_session, club)
vk = vk_session.get_api()
upload = VkUpload(vk_session)
#init DB
try:
db = data_base.DB()
except:
print("Error with connect to database")
logging.error("Critical error with connect to database")
exit(1)
#init keyboads class
kb = keyboards.KB()
async def load_characters_f():
def week_diary():
"""функция для формирования неделбного дневника"""
im = Image.new('RGB', (1920, 1080), color='#CCEEFF')
font = ImageFont.truetype("arial.ttf", 14)
x = 50
y = 8
draw = ImageDraw.Draw(im)
db_sess = db_session.create_session()
user_vk_id = week_diary_command.id
login = db_sess.query(
VkUser.epos_login).filter(VkUser.vk_id == user_vk_id).first()[0]
password = db_sess.query(
VkUser.epos_password).filter(VkUser.vk_id == user_vk_id).first()[0]
epos.run(login, password)
response = epos.get_schedule()
if response == 'timeout':
abort(408)
return 'Сайт ЭПОС.Школа не отвечает. Пожалуйста, повторите запрос.'
flag = False
for day in response.keys(): # создание картинки с данными
y += 2
if response[day]['lessons']:
message = f'{day}'
draw.text((20, y), message, font=font, fill='#1C0606')
y += 18
for lesson_id in range(len(response[day]['lessons'])):
message = response[day]['lessons'][lesson_id].split(' ')
if message[0] == 'Алгебра':
flag = True
draw.text((x, y),
' '.join(message[:3]),
font=font,
fill='#1C0606')
draw.text((x, y + 18),
' '.join(message[3:]),
font=font,
fill='#1C0606')
elif len(message) > 2:
flag = True
draw.text((x, y),
' '.join(message[:2]),
font=font,
fill='#1C0606')
draw.text((x, y + 18),
' '.join(message[2:]),
font=font,
fill='#1C0606')
else:
draw.text((x, y), ' '.join(message), font=font, fill='#1C0606')
if response[day]['homeworks'][lesson_id]:
message = response[day]['homeworks'][lesson_id].split(' ')
if len(message) > 33:
draw.text((x + 180, y),
' '.join(message[:34]),
font=font,
fill='#1C0606')
y += 18
draw.text((x + 180, y),
' '.join(message[34:]),
font=font,
fill='#1C0606')
else:
draw.text((x + 180, y),
' '.join(message),
font=font,
fill='#1C0606')
if flag:
y += 36
flag = False
else:
y += 20
im.save('photo.jpg')
vk_session = VkApi(token=TOKEN)
vk = vk_session.get_api()
response = VkUpload(vk).photo_messages('photo.jpg')[0]
owner_id = response['owner_id']
photo_id = response['id']
access_key = response['access_key']
attachment = f'photo{owner_id}_{photo_id}_{access_key}'
message = ''
return message, attachment
