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']))
