def automeme(random_mem):
try:
r = requests.get('https://api.vk.com/method/wall.get',
params={
'access_token': str(token),
'v': 5.103,
'domain': 'bugzhacks',
'count': 1,
'offset': random_mem
}
)
all_post = []
data = r.json()['response']['items']
all_post.extend(data)
for post in all_post:
url = post['attachments'][0]['photo']['sizes'][7]['url']
img = urllib.request.urlopen(url).read()
out = open("meme.jpg", "wb")
out.write(img)
upload = vk_api.VkUpload(vk_session)
photo = upload.photo(
'meme.jpg',
album_id=271566877,
group_id=193571079
)
photo_url = 'photo{}_{}'.format(
photo[0]['owner_id'], photo[0]['id']
)
vk.wall.post(owner_id="-193571079", from_group=1, attachments=photo_url)
except:
print("Ошибка")
automeme(random_mem=randint(1,500))
def main():
vk_session = vk_api.VkApi(token='token')
print('Bot started!')
vk = vk_session.get_api()
group_id = int(id)
longpoll = VkBotLongPoll(vk_session, str(group_id))
upload = vk_api.VkUpload(vk_session)
def listener(event, vk, vk_session, upload, longpoll, group_id):
if event.type == VkBotEventType.MESSAGE_NEW and event.object.text.strip(
) != '':
uid = event.obj.from_id
text = event.obj.text
messages(event, vk_session, vk, longpoll, upload, uid, text,
start_keyboard)
if 'payload' in event.object:
payload = event.object['payload']
if payload[:8] == '{"key":"':
uid = event.obj.from_id
text = payload[8:][:-2]
keyfunc(uid, text, vk, vk_session, event)
for event in longpoll.listen():
listen = Thread(target=listener,
name=str(random()),
args=(event, vk, vk_session, upload, longpoll,
group_id))
listen.start()
def main():
# Setting up all basic variables
config = ConfigHandler()
vk_session = vk_api.VkApi(config.login, config.password)
vk = vk_session.get_api()
upload_tool = vk_api.VkUpload(vk_session)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
print('Bot is running...')
# Monitor for new messages
longpoll = VkLongPoll(vk_session)
for event in longpoll.listen():
if event.type == VkEventType.MESSAGE_NEW and event.to_me:
sender_id = None
if event.from_user:
sender_id = event.user_id
elif event.from_chat:
sender_id = event.chat_id
elif event.from_group:
sender_id = event.group_id
thread = threading.Thread(target=processing_images,
args=(vk, sender_id, upload_tool,
config))
thread.start()
def send_coupons(self):
# for coupons uploading
vk_session = vk_api.VkApi('login', 'password')
vk_session.auth(token_only=True)
upload = vk_api.VkUpload(vk_session)
# for sending messages
vk_session_2 = vk_api.VkApi(token='token')
vk = vk_session_2.get_api()
while True:
name = self.q.get()
# uploading coupon image to group album
photo = upload.photo(name,
album_id='album_id',
group_id='group_id')
# formimg attachment
attachments = []
attachments.append('photo{}_{}'.format(photo[0]['owner_id'],
photo[0]['id']))
# sending message with attachment
vk.messages.send(user_id='user_id',
attachment=','.join(attachments),
message='Your QR-code!',
random_id=randint(1, 10000))
time.sleep(1)
def messaging(self):
vk_session = vk_api.VkApi('login', 'pass')
vk_session.auth(token_only=True)
upload = vk_api.VkUpload(vk_session)
vk_session2 = vk_api.VkApi(token='token')
vk2 = vk_session2.get_api()
while True:
name = self.q.get()
#грузим в альбом
photo = upload.photo(name, album_id='a_id', group_id='g_id')
attachments = []
attachments.append('photo{}_{}'.format(photo['owner_id'],
photo['id']))
#отправляем в ЛС
vk2.messages.send(user_id='u_id',
attachment=','.join(attachments),
message='Ваш код готов!',
random_id=randint(1, 999999))
sleep(0.5)
def run(self):
vk_session = vk_api.VkApi(token=self.request_info.bot_obj.api_key)
vk = vk_session.get_api()
url = 'http://botov_speech_synthesis:5000/'
# voice = random.choice(['anna', 'aleksandr', 'elena', 'irina'])
voice = 'aleksandr'
speech_resp = requests.post(url,
data={
'voice': voice,
'message': self.message
})
if speech_resp.status_code == 200:
try:
upload = vk_api.VkUpload(vk_session)
file = "/usr/share/RHVoice-data/" + speech_resp.text # docker volume
audio_message = upload.audio_message(
file,
peer_id=self.request_info.request['object']['peer_id'])
doc = "doc{}_{}".format(
audio_message['audio_message']['owner_id'],
audio_message['audio_message']['id'])
vk.messages.send(
random_id=get_random_id(),
attachment=doc,
peer_id=self.request_info.request['object']['peer_id'])
os.remove(file)
except:
pass
def search_for_banks(vk, vk_session, uid, geo):
"""организации. ищет ближайшие к выбранному местоположению, формирует и выводит список"""
if not geo: # проверка было ли выбрано местоположение
raise GeoError
ll = str(geo['coordinates']['longitude']) + ',' + str(geo['coordinates']['latitude']) # получение координат
span = "0.003,0.003"
banks = find_businesses(ll, span, users_data[uid]['type']) # поиск организаций
message = []
pt = [ll + ',home']
for i in range(len(banks)):
pt.append(f'{",".join(list(map(str, banks[i]["geometry"]["coordinates"])))},pm2blm{i + 1}') # добавление метки
bank = banks[i]["properties"]["CompanyMetaData"] # информация об организации
try:
hours = bank["Hours"]["text"]
except Exception:
hours = ''
try:
phone = bank['Phones'][0]["formatted"]
except Exception:
phone = ''
message.append('\n'.join(
[f'{i + 1}. {bank.get("name", "")}', 'Адрес: ' + bank.get("address", ""), 'телефон: ' + phone,
'режим работы: ' + hours]))
if show_map(pt): # получение карты
upload = vk_api.VkUpload(vk_session)
photo = upload.photo_messages('static/img/map.png')[0]
attachment = f'photo{photo["owner_id"]}_{photo["id"]}'
else:
attachment = None
vk.messages.send(user_id=uid,
message='\n\n'.join(message), attachment=attachment,
random_id=get_random_id(), dont_parse_links=1)
menu(vk, uid)
def kick(chat_id, username, kick_command, sex_id):
try:
urls = ['kick1', 'kick2', 'kick3', 'kick4', 'kick5', 'kick6', 'kick7']
random_url = random.choice(urls) + '.jpg'
random_url = '/usr/local/bin/evabot/kicks/' + random_url
upload = vk_api.VkUpload(vk)
photo = upload.photo_messages(random_url)
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}"
kick_command = kick_command.split(' ')
kick_command.pop(0)
if 'тест' in kick_command:
kick_command.remove('тест')
kick_command = ' '.join(kick_command)
if sex_id == 1:
postfix = 'а'
else:
postfix = ''
if ':' in kick_command:
kick_command = kick_command.split(':')
name = kick_command[0]
with_words = kick_command[1]
vk.messages.send(peer_id=chat_id, random_id=get_random_id(),
message=f'{username} ударил{postfix} {name} со словами: "{with_words}" 👊',
attachment=attachment)
else:
name = kick_command
vk.messages.send(peer_id=chat_id, random_id=get_random_id(),
message=f'{username} ударил{postfix} {name} 👊',
attachment=attachment)
except Exception:
send_message(chat_id, 'Ошибка. Запишите команду, как на примере: "Ева ударить Обама" или '
'"Ева ударить Обама: получай!"')
def send(self, text, to, attachments=[], photos=[]):
_attachments = []
for doc in attachments:
d = doc[doc['type']]
s = f"{doc['type']}{d['owner_id']}_{d['id']}"
if 'access_key' in d:
s += '_' + d['access_key']
_attachments.append(s)
if photos:
upload = vk_api.VkUpload(self.vk_session)
for photo in upload.photo_messages(photos=photos):
_attachments.append(f"photo{photo['owner_id']}_{photo['id']}")
if not text and not _attachments:
text = 'empty'
text = str(text)
rd_id = vk_api.utils.get_random_id()
self.vk.messages.send(peer_id=to,
random_id=rd_id,
message=text[:4000],
attachment=','.join(_attachments))
if len(text) > 4000:
time.sleep(0.4)
self.send(text[4000:], to)
def main():
""" Пример загрузки фото """
login, password = '******', 'fedor12345'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth(token_only=True)
except vk_api.AuthError as error_msg:
print(error_msg)
return
""" В VkUpload реализованы методы загрузки файлов в ВК
"""
upload = vk_api.VkUpload(vk_session)
photo = upload.photo( # Подставьте свои данные
'py.png',
album_id=261375384,
group_id=179758165)
vk_photo_url = 'https://vk.com/photo{}_{}'.format(photo[0]['owner_id'],
photo[0]['id'])
print(photo, '\nLink: ', vk_photo_url)
def send_kek(chat_id, username):
url1 = 'photo1.jpg'
url2 = 'photo2.jpg'
upload = vk_api.VkUpload(vk)
photo1 = upload.photo_messages(url1)
photo2 = upload.photo_messages(url2)
owner_id = photo1[0]['owner_id']
photo_id = photo1[0]['id']
access_key = photo1[0]['access_key']
attachment1 = f'photo{owner_id}_{photo_id}_{access_key}'
owner_id = photo2[0]['owner_id']
photo_id = photo2[0]['id']
access_key = photo2[0]['access_key']
attachment2 = f'photo{owner_id}_{photo_id}_{access_key}'
vk.messages.send(peer_id=chat_id, random_id=get_random_id(),
message=f'{username}, держи',
attachment=[attachment1, attachment2])
os.remove('photo1.jpg')
os.remove('photo2.jpg')
def send_a_meme(text, id, vk_session):
unnamed_meme_cat = False
global priority, dict_numbers_memes, input_zdraste, my_dela, my_creator
if 'постирон' in text:
pass
elif 'черн' in text and 'юмор' in text:
pass
elif 'школ' in text:
print(text)
name_of_picture = f"G:\ДИМА\ВКонтакте\ВК бот\Мемы\Школа\sch{random.randint(1, dict_numbers_memes['школа'])}.jpg"
elif 'интелл' in text or 'добр' in text:
pass
elif 'программирование' in text:
print(text)
name_of_picture = f"G:\ДИМА\ВКонтакте\ВК бот\Мемы\Программирование\prog{random.randint(1, dict_numbers_memes['программирование'])}.jpg"
elif 'гачи' in text or 'gachi' in text or 'dunge' in text or 'cum' in text or 'slave' in text or 'muchi' in text:
pass
else:
name_of_picture = f"G:\ДИМА\ВКонтакте\ВК бот\Мемы\Школа\sch{random.randint(1, dict_numbers_memes['школа'])}.jpg"
unnamed_meme_cat = True
upload = vk_api.VkUpload(vk_session)
photo = upload.photo_messages([name_of_picture])
print(photo)
vk_photo_id = f"photo{photo[0]['owner_id']}_{photo[0]['id']}"
print(vk_photo_id)
vk = vk_session.get_api()
vk.messages.send(user_id=id,
attachment=[vk_photo_id],
random_id=random.randint(0, 2**64))
def upload_content(self, vk_session, user_id, group_id):
upload = vk_api.VkUpload(vk_session)
self.__attachments = ''
self.__message = ''
if self.__photos:
photos_path = [self.__path + '/' + photo for photo in self.__photos]
photos = upload.photo_wall(photos_path, user_id, group_id)
atcms = ['photo' + str(photo['owner_id']) + '_' + str(photo['id']) for photo in photos]
atcms = ','.join(atcms)
self.__attachments = ','.join( (self.__attachments, atcms) )
if self.__docs:
for doc in self.__docs:
path = self.__path + '/' + doc
dct = upload.document_wall(path, doc[:-4])
atcmt = 'doc' + str(dct[0]['owner_id']) + '_' + str(dct[0]['id'])
self.__attachments = ','.join( (self.__attachments, atcmt) )
if self.__attachments_file:
with open(self.__path + '/' + self.__attachments_file, 'rb') as f:
for line in f:
self.__attachments = ','.join( (self.__attachments, line.decode('utf-8')) )
if self.__message_file:
with open(self.__path + '/' + self.__message_file, 'rb') as f:
for line in f:
self.__message += line.decode('utf-8')
def __init__(self, args, vk_session, id):
ls = os.listdir(None)
if self._cheack_audio(ls) is True:
self.__task_messages = list()
vk = vk_session.get_api()
upload = vk_api.VkUpload(vk_session)
tasks = list()
if args[0] == "bot":
chats = args[2]
else:
chats = args[3]
for file in ls:
if file[-3:] == "mp3" or file[-3:] == "ogg":
task = Thread(name=file,
target=self.__task,
args=(file, chats, upload, vk, id),
daemon=True)
tasks.append(task)
task.start()
for task in tasks:
task.join()
for m in self.__task_messages:
for i in m:
pass
def main():
login, password = LOGIN, PASSWORD
vk_session = vk_api.VkApi(
login,
password,
# функция для обработки двухфакторной аутентификации
auth_handler=auth_handler)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
upload = vk_api.VkUpload(vk_session)
photos = ['static/img/img.png', 'static/img/some_png.png']
album = input('id album plz')
group = input('id group plz')
for i in photos:
photo = upload.photo(i, album_id=album, group_id=group)
vk_url = f"https://vk.com/photo{photo[0]['owner_id']}_{photo[0]['id']}"
vk_id = f"photo{photo[0]['owner_id']}_{photo[0]['id']}"
vk = vk_session.get_api()
vk.wall.post(message="yanTestFUNC", attachments=[vk_id])
print('>> error: 0 ')
def post_day_count(image_file_name=None) -> None:
assert VK_LOGIN
assert VK_PASS
vk_session = vk_api.VkApi(VK_LOGIN, VK_PASS)
vk_session.auth()
vk = vk_session.get_api()
day_number = get_day_number()
message = prepare_message_number(day_number)
if image_file_name:
upload = vk_api.VkUpload(vk_session)
photo = upload.photo_wall(
image_file_name,
group_id=GROUP_ID,
)[0]
owner_id, media_id = photo.get('owner_id'), photo.get('id')
photo_attachment = f'photo{owner_id}_{media_id}'
data_to_post = dict(owner_id=f'-{GROUP_ID}',
message=message,
attachments=photo_attachment)
else:
data_to_post = dict(owner_id=f'-{GROUP_ID}', message=message)
# TODO add retry
post_response = vk.wall.post(**data_to_post)
print(post_response)
def __init__(self):
self.vkSession = vk_api.VkApi(token=ACCESS_TOKEN)
logging.info("Successfully created vk session")
photo_list = vk_api.VkUpload(self.vkSession).photo_wall(OUTPUT_PATH)
self.photo = ','.join('photo{owner_id}_{id}'.format(**item) for item in photo_list)
logging.info("Photo id was received")
def main():
session = requests.Session()
login, password = '******', 'password'
vk_session = vk_api.VkApi(login, password, auth_handler=auth_handler)
vk = vk_session.get_api()
upload = vk_api.VkUpload(vk_session)
vk_session.auth()
def photo_uploader(photo_link, filename):
image = requests.get(photo_link, stream=True)
with open(filename, 'wb') as fd:
fd.write(image.content)
photo = upload.photo(filename, album_id=265319479, group_id=158982770)
return 'photo%s_%s' % (photo[0]['owner_id'], photo[0]['id'])
film_base = jRW.read_json('films_ready.json')
result = []
for film in film_base:
if 'pic' in film and film['pic']:
film['pic'] = photo_uploader(film['pic'],
'photos/' + film['name'] + '.jpg')
result.append(film)
print(film['name'] + ' done')
jRW.write_json(result, 'films_ready2.json')
def Film_popular(*args):
film = KinoPoisk.get_random_popular()
# Загрузка фото на комп
p = requests.get(film[4])
out = open("film.jpg", "wb")
out.write(p.content)
out.close()
# Отправка фото в ВК:
upload = vk_api.VkUpload(vk)
photo = upload.photo_messages('film.jpg')
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}'
film_janr = ''
for i in film[6]:
film_janr += i + ', '
vk.messages.send(peer_id=args[0].message.peer_id,
random_id=0,
attachment=attachment,
message='Название: ' + film[0] + '\nРейтинг: ' +
str(film[5]) + '\nДата премьеры: ' + str(film[2]) +
'\nЖанры: ' + film_janr + '\n\n' + 'Описание:\n' +
film[1] + '\n\nСсылка на фильм: ' + film[7])
def send_respond(self, client_id, aim_id):
path = 'VkLikeBot/Clients_Data/'
with open(path + 'to_plots_instruction.txt', 'r') as file:
fifth = file.read()
with open(path + 'add.txt', 'r') as file:
sixth = file.read()
with open(path + 'game_of_thrones.txt', 'r') as file:
seventh = file.read()
with open('{}{}/attractives.txt'.format(path, aim_id), 'r') as file:
second = file.read()
if second == '':
second = 'Выбранный человек ни в ком не интересуется. Может стоит поискать среди другого пола? ;)'
with open('{}{}/fans.txt'.format(path, aim_id), 'r') as file:
fourth = file.read()
if fourth == '':
fourth = 'В выбранном человеке никто не интересуется. Может стоит поискать среди другого пола? ;)'
first = 'Результат проверки https://vk.com/id{}'.format(aim_id)
first_photo_loc = '{}{}/attractives.png'.format(path, aim_id)
second_photo_loc = '{}{}/fans.png'.format(path, aim_id)
upload = vk_api.VkUpload(session)
attachments = []
photo = upload.photo_messages(first_photo_loc)
attachments.append('photo{}_{}'.format(photo[0]['owner_id'],
photo[0]['id']))
api_community.messages.send(peer_id=client_id,
message=first,
attachment=','.join(attachments),
random_id=get_random_id())
api_community.messages.send(peer_id=client_id,
message=second,
random_id=get_random_id())
attachments = []
photo = upload.photo_messages(second_photo_loc)
attachments.append('photo{}_{}'.format(photo[0]['owner_id'],
photo[0]['id']))
api_community.messages.send(peer_id=client_id,
message='',
attachment=','.join(attachments),
random_id=get_random_id())
api_community.messages.send(peer_id=client_id,
message=fourth,
random_id=get_random_id())
api_community.messages.send(peer_id=client_id,
message=fifth,
random_id=get_random_id())
if aim_id is client_id: #Если заявка бесплатная, то отправляем сообщение с рекламой
api_community.messages.send(peer_id=client_id,
message=sixth,
random_id=get_random_id())
api_community.messages.send(peer_id=client_id,
message=seventh,
random_id=get_random_id())
def get_captcha():
captcha = ""
for i in range(6):
captcha += random.choice(char_list)
print(captcha)
im = Image.open("images/captcha.jpg")
im1 = Image.open("images/captcha4.jpg")
im2 = Image.open("images/captcha5.jpg")
im3 = Image.open("images/captcha6.jpg")
im4 = Image.open("images/captcha2.jpg")
im5 = Image.open("images/captcha7.jpg")
draw_text = ImageDraw.Draw(im)
wText, hText = draw_text.textsize(captcha, font)
wIm, hIm = im.size
#print(wIm, hIm, wText, hText)
draw_text.text(((wIm - wText) / 2, 160),
str(captcha),
font=font,
fill=(0, 0, 0, 128))
Image.blend(
Image.blend(
Image.blend(Image.blend(Image.blend(im, im1, 50), im2, 50), im3,
50), im4, 50), im5,
50).save('images/captcha3.jpg'.format(username))
upload = vk_api.VkUpload(vk)
photo = upload.photo_messages("images/captcha3.jpg")
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}'
print(attachment)
return attachment, captcha
def main():
""" Пример: загрузка фото """
login, password = '******', 'mypassword'
vk = vk_api.VkApi(login, password)
try:
vk.authorization()
except vk_api.AuthorizationError as error_msg:
print(error_msg)
return
"""
В VkUpload реализованы методы загрузки файлов в ВК.
(Не все, если что-то понадобится - могу дописать)
"""
upload = vk_api.VkUpload(vk)
photo = upload.photo( # Подставьте свои данные
'D:/downloads/tube.jpg',
album_id=200851098,
group_id=74030368)
vk_photo_url = 'https://vk.com/photo{}_{}'.format(photo[0]['owner_id'],
photo[0]['id'])
print(photo, '\nLink: ', vk_photo_url)
def main():
login, password = '******', 'nlaalnooн'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth(token_only=True)
except vk_api.AuthError as error_msg:
print(error_msg)
return
upload = vk_api.VkUpload(vk_session)
photos = ['static/img/pic_cat.jpg', 'static/img/kitten.jpg']
for item in photos:
photo = upload.photo(
item,
album_id=457239018,
group_id=193282244
)
vk_photo_url = 'https://vk.com/photo{}_{}'.format(
photo[0]['owner_id'], photo[0]['id']
)
vk_photo_id = f"photo{photo[0]['owner_id']}_{photo[0]['id']}"
print(photo, vk_photo_id, vk_photo_url, sep="\n")
vk = vk_session.get_api()
vk.wall.post(message="Cats", attachments=[vk_photo_id])
def _upload(url):
fname = url.split("/")[-1]
fname = fname.split('?')[0]
filename = "upload/" + fname
try:
if "http" in url:
r = requests.get(url, stream=True)
if r.status_code == 200:
with open(filename, 'wb') as f:
for chunk in r.iter_content(1024):
f.write(chunk)
upload = vk_api.VkUpload(Vk.session)
photo = upload.photo_wall(filename, group_id=Vk.group_id)
except requests.exceptions.ConnectionError as error:
Log.log(error)
return False
except vk_api.exceptions.ApiError as error:
Log.log(error)
return False
os.remove(filename)
return 'photo{}_{}'.format(photo[0]['owner_id'], photo[0]['id'])
def main():
""" Пример загрузки фото """
login, password = '******', 'mypassword'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.authorization()
except vk_api.AuthorizationError as error_msg:
print(error_msg)
return
""" В VkUpload реализованы методы загрузки файлов в ВК
"""
upload = vk_api.VkUpload(vk_session)
photo = upload.photo( # Подставьте свои данные
'/root/3301.jpg',
album_id=200851098,
group_id=74030368)
vk_photo_url = 'https://vk.com/photo{}_{}'.format(photo[0]['owner_id'],
photo[0]['id'])
print(photo, '\nLink: ', vk_photo_url)
def make_vk_post(session):
upload = vk_api.VkUpload(session)
print(vk.wall.post(owner_id='-195708808',message='Rick', attachments='photo-195708808_457239017'))
photo = upload.photo(
'morty-1.jpg',
album_id=272483036,
group_id=195708808)
def delivery_graphics(filenames):
# 1-Логинимся как пользователь в вк
# 2-Загружаем список файлов на сервере вк
# 3-При успешной загружке удаляем графики на нашем сервере
# 4-Формируем список ссылок на загруженные файлы из json,
# полученном на 2 шагe
vk_session = vk_api.VkApi(LOGIN, PASSWORD) # 1
try:
vk_session.auth(token_only=True)
except vk_api.AuthError as error_msg:
print(error_msg)
upload = vk_api.VkUpload(vk_session)
grafics = [i + ".png" for i in filenames]
uploaded = upload.photo(grafics, album_id=ALBUM_ID, group_id=GROUP_ID) # 2
uploaded_url = [
"photo{}_{}".format(
uploaded[uploaded.index(i)]["owner_id"],
uploaded[uploaded.index(i)]["id"],
) for i in uploaded
] # 4
if uploaded_url:
for i in grafics:
os.remove(i) # 3
return uploaded_url
def vk_poster(vk_token,
vk_app,
vk_group,
text=None,
bold=None,
pics=None,
urls=None):
if not (text or pics):
raise ValueError("Not Text or Pics")
vk_session = vk_api.VkApi(token=vk_token, app_id=vk_app)
vk = vk_session.get_api()
attachs = []
if pics:
vk_response = vk.photos.getAlbums(owner_id=vk_group)
album = vk_response['items'][0]['id']
upload = vk_api.VkUpload(vk_session)
for pic in pics:
photo = upload.photo(pic, album_id=album, group_id=abs(vk_group))
photo_url = "photo{}_{}".format(vk_group, photo[0]['id'])
attachs.append(photo_url)
if urls:
attachs.append(urls[0])
vk_response = vk.wall.post(owner_id=vk_group,
from_group=1,
message=text,
attachments=",".join(attachs))
post_id = vk_response['post_id']
return post_id
def upload_photo_vkontakte(image_path):
vk_session = vk_api.VkApi(login=VK_LOGIN, token=VK_TOKEN)
upload = vk_api.VkUpload(vk_session)
photo = upload.photo(image_path,
album_id=VK_ALBUM_ID,
group_id=VK_GROUP_ID)
return f'photo{photo[0]["owner_id"]}_{photo[0]["id"]}'
def upload_images(vk, file_names):
upload = vk_api.VkUpload(vk)
rs = upload.photo_messages(file_names)
# Составление названия изображений: https://vk.com/dev/messages.send
attachment = ','.join('photo{owner_id}_{id}'.format(**item) for item in rs)
return attachment
