def login (): if token == '': return True else: session = vk.Session(access_token=token) return vk.API(session ,v='5.92', lang='ru')
#from django.shortcuts import render import time import vk import requests import json from pyrogram import Client try: result = json.loads(requests.get('http://193.124.117.173:8000/api/all?key=c21e9d9f7c68192ef79c2a6dddcbb953', timeout=90).text) ids = '' has_vk = list(filter(lambda x:x['vk_id']!='', result)) for i in has_vk: ids += str(i['vk_id']) + ', ' api = vk.API(session = vk.Session(access_token = '')) app = Client( 'roctbb228bot', api_id=864763, # your api_id api_hash='', proxy=dict( hostname="", port=, username="", password="" ) ) while True: print('sleep') #time.sleep(600 - (time.time() % 600)) print('wake_up') t = time.time() - 600
def get_api(self): session = vk.AuthSession(app_id=MyVKData.APP_ID, user_login=MyVKData.LOGIN, user_password=MyVKData.PASSWORD()) vkapi = vk.API(session) return vkapi
import os from datetime import datetime import vk from Bot.Basis.Functions.getSchedule import getTimetableDict from Bot.Basis.Functions.getWeatherForecast import getWeather token = os.environ['TOKEN'] confirmation_token = os.environ['CONFIRMATION_TOKEN'] weatherForecast = getWeather() path = os.path.split(os.path.abspath(__file__))[0] timetableDict = getTimetableDict() isUpper = True if (datetime.now().isocalendar()[1] % 2 == 0) else False session = vk.Session(token) api = vk.API(session, v=5.85)
def __init__(self, accessToken): self.accessToken = accessToken self.session = vk.Session(access_token=accessToken) self.api = vk.API(self.session) self.frequency = 0.3
def get_vk_session(self, token): session = vk.Session(access_token=token) return vk.API(session, v=5.103)
import vk from time import sleep gg vp session=vk.AuthSession(str(6061551),input("Login:"******"Password:"******"5.62") def forallitems(itemsfunc,func,offs,*itemargs,**itemkwargs): ofs=0 items=itemsfunc(*itemargs,**itemkwargs) cont=items["count"] requests=0 while cont>0: cont-=len(items["items"]) for item in items["items"]: if not func(item): return None if cont>=ofs: ofs+=offs else: ofs=cont items=itemsfunc(*itemargs,offset=ofs,**itemkwargs) requests+=1 if requests==3: requests=0 sleep(1) class Post: def __init__(self,oid,pid): self.id=str(oid)+"_"+str(pid) def __repr__(self): return self.id class User: def __init__(self, uid):
import vk import random import time session = vk.Session( access_token="ТОКЕН, создайте приложение и вставте его сюда") vk_api = vk.API(session, v='5.62') ass = vk_api.messages.getDialogs(count=10) for msg in ass['items']: if 'chat_id' in msg['message']: print("Название беседы:", msg['message']['title'], "Чат-айди -", msg['message']['chat_id']) chaterid = int( input("Введите чат где вы хотите выбрать пидора дня!\n Чат-айди: ")) a = vk_api.messages.getChat(chat_ids=chaterid) a = a[0]["users"] pidor = random.choice(a) b = "[id" + str( pidor) + "|Пидор дня]\nМои поздравления! \nДата(мск+1): " + time.strftime( '%Y-%m-%d %H:%M:%S') print(b, "\n Дата(мск+1):", time.strftime('%Y-%m-%d %H:%M:%S')) goodman = "Лучший юзер дня" vk_api.messages.send(chat_id=chaterid, message=b) #vk_api.wall.post(message='hello world!',attachments="photo285056992_466257441")
def firstZero(num): if num < 10: return '0' + str(num) else: return str(num) ########## ########## session = vk.Session( access_token= 'eba55bc9b524ce80e710a904f7b3eeae10113381d0d5a895c3bf5efd463f93ae746a18a2cdaf5106046cb' ) api = vk.API(session, lang='en') owm = pyowm.OWM('1bc7daa3d4206a5608fa3cc8e4abc03d') ser = serial.Serial('COM4') # open serial port observation = owm.weather_at_place('Minsk,BY') w = observation.get_weather() i = 0 temp = '' while True: now_time = datetime.datetime.now() message = api.messages.get(time_offset=0) if len(message) != 1 and message[1]['read_state'] == 0:
def main(cmd_args): app_config = configparser.ConfigParser() app_config.read(cmd_args.config_file) proxy_type = app_config.get(CONFIG_SECTION_TELEGRAM, "proxy_type", fallback=None) proxy_host = app_config.get(CONFIG_SECTION_TELEGRAM, "proxy_host", fallback=None) proxy_auth = app_config.get(CONFIG_SECTION_TELEGRAM, "proxy_auth", fallback="") tg_session = app_config.get(*OPTION_ACCESS_TGSESSION, fallback=None) try: tg_client = telethon.TelegramClient( tgauth.StringSession(tg_session), app_config.get(CONFIG_SECTION_TELEGRAM, "api_id"), app_config.get(CONFIG_SECTION_TELEGRAM, "api_hash"), sequential_updates=True, **get_proxy_args(proxy_type, proxy_host, proxy_auth)) if cmd_args.init: init_interactive(app_config, tg_client) vk_api = vk.API(vk.Session(app_config.get(*OPTION_ACCESS_VKTOKEN)), version='5.95') if cmd_args.setup: if not tg_client.is_connected(): tg_client.connect() setup_interactive(app_config, tg_client, vk_api) finally: with open(cmd_args.config_file, 'w') as output_file: app_config.write(output_file) source_channel_id = int(app_config.get(*OPTION_TELEGRAM_SOURCE)) target_group_id = -int(app_config.get(*OPTION_VKONTAKTE_TARGET)) async def CB_tg_update_handler(event): # TODO: Make this fault tolerant. if event.message.to_id.channel_id != source_channel_id: return #print(event.stringify()) print('\nsource id: {}\n{}\n'.format(event.message.id, event.message.message)) result = vk_api.wall.post(owner_id=target_group_id, from_group=True, message=event.message.message, guid=str(event.message.id)) print('target id: {}\n'.format(result.get('post_id'))) tg_client.add_event_handler(CB_tg_update_handler, tgevent.NewMessage) while True: try: if not tg_client.is_connected(): print('attempting to connect to Telegram...') tg_client.connect() print('successfully connected') # since this performs a "high level request", Telegram will # understand that we need updates, so it should send them to us if not tg_client.is_user_authorized(): raise tgerror.UnauthorizedError() # TODO: Call getChannelDifference and queue its result for posting. print('\nnow monitoring (press Ctrl+C to exit)') tg_client.loop.run_until_complete(tg_client.disconnected) except (SystemExit, KeyboardInterrupt): break except (tgerror.UnauthorizedError): raise except Exception as e: # just in case if tg_client.is_connected(): tg_client.disconnect() print('sleeping, wait a while...') time.sleep(10)
from mongoengine import * import vk import time vk.logger.setLevel('DEBUG') session = vk.AuthSession(access_token="a99700af7dba22bc9d6224959a879db1382663867a132f6fa066123461ef714b48e9f3f92aac316fa9e77") api = vk.API(session, v='5.35', lang='ru', timeout=1000) def loadUser(user_id): return api.users.get(user_ids=user_id, fields=["first_name", "last_name", "deactivated", "verified", "sex", "bdate", "city", "country", "home_town", "photo_100", "education", "universities", "schools", "status", "last_seen", "followers_count", "counters"]) default_sleep = 0.25 with open("4_1_876.txt", "rt") as txt_ids: lines = txt_ids.readlines() for num, line in enumerate(lines): print(num) time.sleep(default_sleep) print(loadUser(line.rstrip())) class User(Document): user_id = IntField(required=True) first_name = StringField() last_name = StringField() screen_name = StringField()
import shutil import datetime import sys import traceback import imghdr print('[GoogleImageSearch]Starting up...') boot_ts = datetime.datetime.now() cx = '' googleApiKey = '' vkToken = '' searchUrl = 'https://www.googleapis.com/customsearch/v1?&cx=' + cx + '&key=' + googleApiKey + '&cx=' + cx + '&num=10&searchType=image&q=' print('[GoogleImageSearch]Initializing VK API') api = vk.API(vk.AuthSession(access_token=vkToken), v=5.95) print('[GoogleImageSearch]Initializing filesystem...') if not os.path.exists('logs'): os.makedirs('logs') log_path = 'logs/' + str(datetime.date.today()) + '_' + boot_ts.strftime('%H-%M-%S') + '.log' if os.path.exists(log_path): os.remove(log_path) open(log_path, 'w').close() print('[GoogleImageSearch]Declarating functiions...') def write_to_log(message): with open(log_path, 'a') as logfile:
parser.add_argument('-p', '--prefix', type=str, default='data/ds', help='Prefix of file with output dataset') return parser.parse_args() if __name__ == '__main__': try: init_logger() args = parse_args() normalizer = Normalizer() config = SourceFileLoader('*', 'server.conf').load_module() database = connect(db=config.mongo_database, host=config.mongo_host, port=int(config.mongo_port), username=config.mongo_username, password=config.mongo_password) access_token = AccessToken(args.tokens) vk_session = vk.Session() vk_api = vk.API(vk_session, v='5.65', lang='ru') def batching(array, batch_size=100): for i in range((len(array) - 1) // batch_size + 1): yield array[i * batch_size:(i + 1) * batch_size] posts = [contest.post_id for contest in Contest.objects()] filename = "%s_%s.list" % (args.prefix, time.strftime("%Y_%m_%d_%H:%M", time.gmtime())) with open("%s.tmp" % filename, 'w') as dataset: for batch in batching(posts): for post in vk_api.wall.getById(posts=','.join(batch), access_token=access_token()): post_id = '%d_%d' % (post['owner_id'], post['id']) dataset.write("%s\t%d\t%s\n" % (post_id, post['date'], normalizer.preprocess(post['text']))) if args.delete: Contest.objects(post_id__in=posts).delete()
import vk import time token = "" session = vk.Session(access_token=token) vk_api = vk.API(session, v='5.89') #метод считает количество общих элементов в двух листах def count_common_elements(list_of_groups1: list, list_of_groups2: list): set1 = set(list_of_groups1) set2 = set(list_of_groups2) set1.intersection_update(set2) return len(set1) # Считаем коэффициент Тонимото. # k = (c/(a+b-c)) # a — количество элементов в первом множестве # b — количество элементов во втором множестве # c — количество общих элементов в двух множествах def tanimoto(id_1: int, id_2: int): first_user_groups = vk_api.groups.get(user_id=id_1).get('items') second_user_groups = vk_api.groups.get(user_id=id_2).get('items') a = len(first_user_groups) b = len(second_user_groups) c = count_common_elements(first_user_groups, second_user_groups) k = (c / (a + b - c)) return k
import vk from my_data import MyVkData session = vk.Session() vkapi = vk.API(session) countries = vkapi.database.getCountries(need_all=1) [print("<li>", country['title'], "</li>") for country in countries]
def post(request): ACCESS_TOKEN = 'eedebcb815835bd33a74a353fe60d525ae13dc940fe2998c3744a8021f5cd4c075160e48636eb0224c548' vkapi = vk.API(vk.Session(ACCESS_TOKEN)) vkapi.wall.post(message='хуи', v=5.92) return (request)
def get_api(access_token): session = vk.Session(access_token=access_token) return vk.API(session, lang='en')
gender = IntField() stage = IntField() bdate = StringField() age = IntField() photo_max_orig = StringField() city_id = IntField() city_name = StringField() country_id = IntField() country_name = StringField() choice_gender = IntField() choice_age = IntField() photo_id = StringField() session = vk.Session() api = vk.API(session, v=5.63, lang="ru") def calculate_age(day, month, year): today = date.today() return today.year - year - ((today.month, today.day) < (month, day)) group_id = main_group_id def getMembersBulk(group_id): first_check = api.groups.getMembers(group_id=group_id, count=1) maximum = first_check["count"] amount = 500 amou = math.ceil(maximum / amount)
def api(access_token, v): return vk.API(access_token=access_token, v=v)
def verifycode(code): session = vk.Session(access_token=code) api = vk.API(session, v=VK_API_VERSION) return dict(api.account.getProfileInfo(fields=[]))
import mimetypes from email import encoders from email.mime.base import MIMEBase from email.mime.text import MIMEText from email.mime.image import MIMEImage from email.mime.audio import MIMEAudio from email.mime.multipart import MIMEMultipart from pprint import pprint import glob import urllib.request import face_recognition service_access_key = open('service.txt').read().splitlines() session = vk.Session(access_token=service_access_key) api1 = vk.API(session, v=5.101, scope='wall') owner_id = open('owner.txt').read().splitlines() admins = {str(i) for i in open('admins.txt').read().splitlines()} loginpassword = open('login_password.txt').read().splitlines() pochta = open('mail.txt').read().splitlines() tokens = open('secret.txt').read().splitlines() vk_session = vk_api.VkApi(token=tokens[0]) vko = vk_session.get_api() app = open('app.txt').read().splitlines() sessio = vk.AuthSession(scope='wall', app_id=app, user_login=loginpassword[0], user_password=loginpassword[1].encode('utf-8').strip()) api = vk.API(sessio, v=5.101) contacts = [] vk_sessio = vk_api.VkApi(loginpassword[0], loginpassword[1], app_id=int(app[0]), scope='wall, photos') vk_sessio.auth() upload = VkUpload(vk_sessio)
def send_doc(message, userid, group, forward_messages=None): filetype = message.content_type session = VkMessage(vk_tokens.get(str(message.from_user.id))).session api = vk.API(session, v=VK_API_VERSION) if filetype == 'document' and 'video' not in message.document.mime_type: file = wget.download( FILE_URL.format( token, bot.get_file(getattr(message, filetype).file_id).wait().file_path)) openedfile = open(file, 'rb') files = {'file': openedfile} fileonserver = ujson.loads( requests.post(api.docs.getUploadServer()['upload_url'], files=files).text) attachment = api.docs.save(file=fileonserver['file'], title=getattr(message, filetype).file_name, tags='') openedfile.close() os.remove(file) elif filetype == 'voice': file = wget.download( FILE_URL.format( token, bot.get_file(getattr(message, filetype).file_id).wait().file_path)) openedfile = open(file, 'rb') files = {'file': openedfile} fileonserver = ujson.loads( requests.post( api.docs.getUploadServer(type='audio_message')['upload_url'], files=files).text) attachment = api.docs.save(file=fileonserver['file'], title='Аудиосообщение', tags='') openedfile.close() os.remove(file) elif filetype == 'document' and 'video' in message.document.mime_type: vk_sender(message, send_video) return else: # filetype == 'audio': file = wget.download( FILE_URL.format( token, bot.get_file(getattr(message, filetype).file_id).wait().file_path)) newfile = file.split('.')[0] + '.aac' os.rename(file, newfile) openedfile = open(newfile, 'rb') files = {'file': openedfile} fileonserver = ujson.loads( requests.post(api.docs.getUploadServer()['upload_url'], files=files).text) attachment = api.docs.save(file=fileonserver['file'], title=audio_title_creator( message, message.audio.performer, message.audio.title), tags='') openedfile.close() os.remove(newfile) if group: if message.caption: api.messages.send(chat_id=userid, message=message.caption, attachment='doc{}_{}'.format( attachment[0]['owner_id'], attachment[0]['did']), forward_messages=forward_messages) else: api.messages.send(chat_id=userid, attachment='doc{}_{}'.format( attachment[0]['owner_id'], attachment[0]['did']), forward_messages=forward_messages) else: if message.caption: api.messages.send(user_id=userid, message=message.caption, attachment='doc{}_{}'.format( attachment[0]['owner_id'], attachment[0]['did']), forward_messages=forward_messages) else: api.messages.send(user_id=userid, attachment='doc{}_{}'.format( attachment[0]['owner_id'], attachment[0]['did']), forward_messages=forward_messages)
}, 'color': 'negative' }]] } msgtemp = '''Пользователь: {0} Аккаунт зарегистрирован: {1} в {2} (по МСК) Аккаунт существует примерно {3} лет {4} месяцев {5} дней С точностью до недель: {6} лет {7} недель {8} дней {9} часов {10} минут {11} секунд''' app = Flask(__name__) session = vk.Session(access_token=access_token) api = vk.API(session, v='5.103') def regday(var_id): url = 'https://vk.com/foaf.php?id=' + str(var_id) headers = {"Accept-Language": "ru-RU,ru;q=0.75"} response = requests.get(url, headers=headers) text = response.text name = text[text.find('<foaf:name>') + 11:text.find('</foaf:name>')] num = text.find('<ya:created') text = text[(num + 21):(num + 46)] dt = datetime.datetime.strptime(text[:19], '%Y-%m-%dT%H:%M:%S') dtn = datetime.datetime.utcnow() offset = datetime.timedelta(hours=int(text[21:22]))
def init_session(self): self.parse_config() session = vk.Session(access_token=self.token) self.vk_api = vk.API(session, v=self.vk_api_version)
groups = userInfo[0]['counters']['groups'] except: groups = 0 return User(Id, age, photos, videos, notes, groups, cityId) except Exception as er: print(er) return session = vk.Session( access_token= '92b4aa39990fae9a5dea78605aba7370b73d71e70f47bcef9878153067c23d0d68a9f46c27ad1ee83b9e7' ) vk_api = vk.API(session) max_deep = 2 startId = 177991274 parsedUsers = [] usersInfo = [] ParseUserFriends(startId, 0) count = 0 for user in parsedUsers: if count % 5 != 0: us = GetUserInfoById(user.id) count += 1 if us is not None: usersInfo.append(us)
class VkSpider(scrapy.Spider): user1 = 'https://vk.com/id259577877' user2 = 'https://vk.com/id14252698' name = 'vk' allowed_domains = ['vk.com'] service_access_key = '446c9e04446c9e04446c9e045044078b664446c446c9e04189341b79fc4fa5d3e1be7a6' version = 5.103 fields = ['domain', 'is_closed', 'can_access_closed', 'deactivated'] session = vk.Session(access_token=service_access_key) vk_api = vk.API(session) start_urls = [user1] user1_id = fetch_user_id(vk_api, user1, version) user2_id = fetch_user_id(vk_api, user2, version) common_dict = {} i = 0 stop, stop_2 = False, False def parse(self, response: HtmlResponse): print(f'Начинаем: {time.asctime()}') itm = self.vk_api.users.get(user_id=self.user1_id, v=self.version)[0] if self.user1_id == self.user2_id: self.stop = True item = VkParseItem( parent_id=None, user_id=itm[0]['id'], user_name=f'{itm[0]["first_name"]} {itm[0]["last_name"]}', user_info=itm[0], ) return (yield item) else: self.common_dict[f'{self.user1_id}'] = (itm, None) yield response.follow( self.user1, callback=self.user_friends_parse, ) def user_friends_parse(self, response: HtmlResponse): if not self.stop: uid = fetch_user_id(vk_api_val=self.vk_api, url=response.url, version=self.version) if uid and get_access_status(self.vk_api, uid, self.version): list_of_friends = self.vk_api.friends.get(user_id=uid, v=self.version, fields=self.fields)['items'] for itm in list_of_friends: if itm['id'] == int(self.user2_id): self.common_dict[self.user2_id] = (itm, uid) self.stop = True elif self.common_dict.get(f"{itm['id']}") is None: item = (itm, uid) self.common_dict[f'{itm["id"]}'] = item url = f'https://vk.com/{itm["domain"]}' print(f'\rПройдено узлов: {self.i}', end='') self.i += 1 yield response.follow( url, callback=self.user_friends_parse, ) else: print(f'\rПройдено узлов: {self.i}', end='') self.i += 1 else: if not self.stop_2: itm_id = self.user2_id route = [] while True: route.append(self.common_dict[f'{itm_id}']) if itm_id != self.user1_id: itm_id = self.common_dict[f'{itm_id}'][1] else: print(f'\nДлина пути между {self.user1} и {self.user2} равна {len(route)}') break while route: itm = route.pop() print(f'id: {itm[0]["id"]}, юзер: {itm[0]["first_name"]} {itm[0]["last_name"]}') item = VkParseItem( parent_id=itm[1], user_id=itm[0]['id'], user_name=f'{itm[0]["first_name"]} {itm[0]["last_name"]}', user_info=itm[0], ) yield item if not route: self.stop_2 = True print(f'Данные записаны в БД: {time.asctime()}') raise CloseSpider('Процесс построения закончен') else: return return
# coding=utf-8 __author__ = 'danilcha' import vk from time import strftime import datetime datetime.datetime.fromtimestamp(int("1284101485")).strftime('%Y-%m-%d %H:%M:%S') # TODO: # New version for Vkontakte api for module ver 2.0a4 and above token = 'TOKEN' # session = vk.Session(access_token=token) vkapi = vk.API(access_token=token) # vkapi = vk.API(session) curr_date = strftime("%d-%m-%Y") wall_message_text= "" # Working groups typical_kirovohrad = "-46631810" scandal_kirovohrad = "-80849532" typical_kirovohrad_boss = "13147598" # Post the composed message to the wall: wall_post = vkapi('wall.post', owner_id=typical_kirovohrad, from_group='1', message=wall_message_text,
def __init__(self): self.vk_api = vk.API(vk.Session(access_token=self.access_token))
class Token_auth: @classmethod def get_api(self), token): session = vk.AuthSession(access_token=token) vkapi = vk.API(session) return vkapi
def get_online_friends(session): api = vk.API(session) friends = api.friends.get() return filter(lambda friend: friend['online'], api.users.get(user_ids=friends, fields=['online']))