def _create_session(**kwargs):
"""child function of log_in()"""
scope = '208900'
# permissions: 65536 == offline; 4096 == messages;
# 8192 == wall; 131072 == docs; 4 == photos;
app_id = '5720412'
token = kwargs.get('token')
key = kwargs.get('key')
if token:
session = vk.AuthSession(access_token=token,
scope=scope,
app_id=app_id)
elif key:
login, password = kwargs['login'], kwargs['password']
session = vk.AuthSession(user_login=login,
user_password=password,
scope=scope,
app_id=app_id,
key=key)
else:
login, password = kwargs['login'], kwargs['password']
session = vk.AuthSession(user_login=login,
user_password=password,
scope=scope,
app_id=app_id)
return session
def __init__(self, username=None, password=None):
"""
Creates a new instance of VkHandler with the API property.
If the username and password are provided, an authorized session is created. If no – non authorized session.
:param username: – a string username
:param password: – a string password
"""
if username and password:
session = vk.AuthSession(
os.environ['APP_ID'],
user_login=username,
user_password=password,
scope='wall, photos, stats, groups, offline')
self.API = vk.API(session=session, version='5.78')
elif os.environ['VK_LOGIN'] and os.environ['VK_PASSWORD']:
session = vk.AuthSession(
os.environ['APP_ID'],
user_login=os.environ['VK_LOGIN'],
user_password=os.environ['VK_PASSWORD'],
scope='wall, photos, stats, groups, offline')
self.API = vk.API(session=session, version='5.78')
else:
self.API = vk.API(session=vk.Session())
def login(msg):
try:
cmd, vk_login, vk_password = msg['text'].split()
tg_id = int(msg['chat']['id'])
users[tg_id] = User(vk_login, vk_password, tg_id)
add_data()
first_name = vk.API(vk.AuthSession(APPLICATION_ID, vk_login, vk_password, scope = 'users')).users.get(v = VK_API_V)[0]['first_name']
last_name = vk.API(vk.AuthSession(APPLICATION_ID, vk_login, vk_password, scope = 'users')).users.get(v = VK_API_V)[0]['last_name']
bot.sendMessage(msg['chat']['id'], 'Hello, {} {}! You\'re successfully logged in!'.format(first_name, last_name))
except:
bot.sendMessage(msg['chat']['id'], 'Something is wrong')
def __init__(self, vk_login, vk_password, tg_id):
self.vk_login = vk_login
self.vk_password = vk_password
self.vk_api_users = vk.API(vk.AuthSession(APPLICATION_ID, vk_login, vk_password, scope = 'users'))
self.vk_id = int(self.vk_api_users.users.get(v = VK_API_V)[0]['id'])
self.vk_name = self.vk_api_users.users.get(v = VK_API_V)[0]['first_name'] + ' ' + self.vk_api_users.users.get(v = VK_API_V)[0]['last_name']
self.tg_id = tg_id
self.vk_api_msg = vk.API(vk.AuthSession(APPLICATION_ID, vk_login, vk_password, scope = 'messages'))
self.ban_list = set()
self.longPollData = self.vk_api_msg.messages.getLongPollServer(need_pts = 1, lp_version = 3, v = VK_API_V)
self.inbox = dict()
self.chats = dict()
def get_online_friends(login, password):
session = vk.AuthSession(
app_id=APP_ID,
user_login=login,
user_password=password,
)
api = vk.API(session)
def GetAPI():
# credentials :
app_id = 'your_app_id'
login = '******'
password = '******'
session = vk.AuthSession(app_id, login, password, scope='messages')
return vk.API(session)
def get_authorized_api(self):
session = vk.AuthSession(app_id=config.VK_APP_ID,
user_login=config.VK_USER_LOGIN,
user_password=config.VK_USER_PASSWORD,
scope=settings.VK_SCOPE)
return vk.API(session, v=self._api_version)
def log_in_vk():
""" Открывает файл с токеном или осуществляет вход по логину """
scope = "friends,photos,audio,video,docs,notes,pages,status,wall,groups,messages,notifications,offline"
app_id = APP_ID
try:
with open("Token", "r") as memory:
token = memory.read()
except Exception as error:
print("NO TOKEN", error)
while True:
log = input("Login: "******"Password: "******"Token", "w") as memory:
memory.write(token)
break
return token
def start_session(login, password, version):
session = vk.AuthSession(app_id=APP_ID,
user_login=login,
user_password=password,
scope="friends")
vk_api = vk.API(session, v=version)
return vk_api
def main():
session = vk.AuthSession(app_id='5587961',
user_login='******',
user_password='******',
scope='wall')
api = vk.API(session)
find = input('Введи запрос vk, например "розыгрыш репост": ')
period = int(input('сколько последних секунд учитывать? '))
count = 0
while True:
time = api.utils.getServerTime()
print('{} ок подожди минуту'.format(time))
a = api.newsfeed.search(q=find,
start_time=time - period,
end_time=time,
count=20)
for i in a[1:]:
query = 'wall' + str(i['from_id']) + '_' + str(i['id'])
count += 1
print('{0}: {1}'.format(count, i['text']))
try:
api.wall.repost(object=query)
except:
print('репост не сделан')
try:
api.likes.add(type='post',
owner_id=i['from_id'],
item_id=i['id'])
except:
print('лайк не поставился')
sleep(random.randint(10, 30))
print('перерыв')
sleep(100)
def poster(token, owner_id, path_folder, time_of_post):
file_name = list_files_folder(path_folder)[0]
message = take_name_from_excel("VK_list.xlsx", file_name)
pic_path = path_folder + file_name
session = vk.AuthSession(access_token=token)
vk_api = vk.API(session)
result = vk_api.docs.getWallUploadServer(v=5.102)['upload_url']
img = {'file': (pic_path, open(r'' + pic_path, 'rb'))}
upload_url = result
response = requests.post(upload_url, files=img)
result = json.loads(response.text)
result = vk_api.docs.save(file=result['file'], v=5.102)
attachments = ("doc" + str(result['doc']["owner_id"]) + "_" +
str(result['doc']["id"]))
upload = vk_api.wall.post(message=message,
publish_date=time_of_post,
owner_id=-1 * (owner_id),
from_group=1,
attachments=attachments,
v=5.102)
response.close()
return (upload, pic_path)
def authSession(login, password):
# get vk session
Session = vk.AuthSession(app_id=000,
user_login=login,
user_password=password,
scope='messages')
return vk.API(Session)
def main(args):
#txt = load_user_text(1)
#print(txt)
#exit(1)
# auth_params = get_auth_params()
sessions = [
vk.AuthSession(**get_auth_params()),
vk.Session(
access_token=
'384caffdac72438ecf840f594ce7c59a0a4976332a5e309c50f55d1a8fe46de70529902f0bec9859e6781'
), #vlad
vk.Session(
access_token=
'1361403386a3b0b48437556596e8500446c16701141f5fe5e1727a1a9025bc36246092b7c500d315711d6'
), #ivan
]
# api = vk.API(sessions[0])
# client = MongoClient()
# db = client.ir_project
# subscript_params = get_groups_params()
# code = create_execute_code(subscript_params, id_list=[1,2], method='groups.get', user_field='user_id')
# result = api.execute(code=code, timeout=60)
# print(len(result))
if args.users:
load_users(api)
if args.wall_posts:
for s in sessions:
try:
print('changing session...')
api_w = vk.API(s, timeout=60)
load_wall_posts(api_w)
except:
continue
if args.subscriptions:
for s in sessions:
try:
print('changing session...')
api = vk.API(s, timeout=60)
load_subsciptions(api)
except:
continue
if args.groups:
for s in sessions:
try:
print('changing session...')
api_w = vk.API(s, timeout=60)
load_groups(api_w)
except:
continue
if args.user_info:
load_user_info(api)
def get_api(app_id, user_login, user_password, api_version):
scope = "friends"
session = vk.AuthSession(app_id=app_id,
user_login=user_login,
user_password=user_password,
scope=scope)
return vk.API(session, v=api_version)
def auth(config):
session = vk.AuthSession(config['app_id'],
config['user_login'],
config['user_password'],
scope='video')
api = vk.API(session)
return api
def log_in_vk(self):
""" Читает токен из файла, иначе - создает по учетным данным. Вовзращает токен """
scope = "friends,photos,audio,video,docs,notes,pages,status,wall,groups,messages,notifications,offline"
app_id = APP_ID
try:
with open("Token", "r") as memory:
token = memory.read()
except Exception as error:
print("Нет токена ВК", error)
while True:
log = input("Login: "******"Password: "******"Не авторизироваться в ВК", error)
else:
token = session.get_access_token()
with open("Token", "w") as memory:
memory.write(token)
break
return token
def __init__(self, api_id, user_login, user_pass):
self.session = vk.AuthSession(scope='messages',
app_id=api_id,
user_login=user_login,
user_password=user_pass)
self.api = vk.API(self.session)
def parss(id_num):
print("1")
try:
print("2")
session = vk.AuthSession(my_app_id,
user_login,
user_password,
scope='wall, messages')
vkapi = vk.API(session, v="5.62")
list_id = vkapi.groups.getMembers(group_id='11111111',
offset=id_num,
count=count_id)
except Exception as err:
print(err)
print("3")
dbase = dbconnect.Add_ids('parsdb', 'phonevk')
print("4")
dbase.addtable()
print("5")
while id_num != int(710000):
try:
print(list_id)
print(len(list_id['items']))
for i in list_id['items']:
t = 1 #random.randint(1, 3)
time.sleep(t)
number_l = vkapi.users.get(user_ids=i, fields='contacts')
#print(number_l)
id_num += 1
print("NUM = ", id_num)
if 'mobile_phone' in number_l[0]:
if number_l[0]['mobile_phone'] != '':
print(number_l[0]['first_name'],
number_l[0]['last_name'],
number_l[0]['mobile_phone'])
user_n = "{0} {1}".format(number_l[0]['first_name'],
number_l[0]['last_name'])
print(user_n, type(user_n))
print(number_l[0]['mobile_phone'],
type(number_l[0]['mobile_phone']))
dbase.addid(user_n, number_l[0]['mobile_phone'])
else:
print("конец очереди должна начаться новая очередь")
time.sleep(10)
list_id = vkapi.groups.getMembers(group_id='1111111',
offset=id_num,
count=count_id)
except Exception as errr:
print(errr)
time.sleep(10)
list_id = vkapi.groups.getMembers(group_id='11111111',
offset=id_num,
count=count_id)
else:
print("vse")
def get_info_by_domain(domain="test"):
print('>>>>>>>>>>>>>', domain)
session = vk.AuthSession(**crd)
api_obj = vk.API(session)
posts = get_json_by_id(api_obj, domain=domain, limit=5000)
stats = get_stats(posts)
rsp = api_obj.wall.get(domain=domain, extended=1)
group = rsp['groups'][0]
print('>>', group)
name = group['name']
link = group['screen_name']
img_link = group['photo_big']
return stats, name, link, img_link
def OnCommand(self, objects):
if objects['from_id'] != 36587626:
return True
self.bot.api.messages.send(user_id=objects['from_id'], message='Ищу обновления...')
session = vk.AuthSession(vk_app, vk_login, vk_password, scope=vk_scope)
api = vk.API(session, v=5.80)
result = api.execute.getUpdateUrl()
if result['v'] > version_bot or len(result['update_plugins']) > 0:
r = requests.get(result['program_url'])
with open('download_update.exe', 'wb') as f:
f.write(r.content)
self.bot.api.messages.send(user_id=objects['from_id'], message='Обновление бота...')
if result['v'] > version_bot:
os.system('start download_update.exe')
else:
os.system('start download_update.exe -noclient')
os._exit(1)
else:
self.bot.api.messages.send(user_id=objects['from_id'], message='Обновлений для бота нет.')
def get_api_user(self): #Авторизуемся только 1 раз при первом запросе
global api_user
if api_user is None:
session_user = vk.AuthSession(app_id=id, user_login='', user_password='')
api_user=vk.API(session_user)
return api_user
else: return api_user
def get_contacts(bot, tele_id):
"""Returns list of your contacts."""
if tele_id == config.USERID:
session = vk.AuthSession(app_id=config.APPID,
user_login=config.LOGIN,
user_password=config.PASSWORD,
scope='messages')
vk_api = vk.API(session, v='5.38')
response = vk_api.messages.getDialogs()
for item in response['items']:
# pdb.set_trace()
if item['message'].get('chat_id'):
chat_name = item['message']['title']
dialog_id = str(2000000000 + item['message']['chat_id'])
else:
user_id = item['message'].get('user_id')
user = vk_api.users.get(user_id=user_id)
chat_name = user[0].get('last_name') + ' ' + user[0].get(
'first_name')
dialog_id = str(user_id)
keyboard = types.InlineKeyboardMarkup()
keyboard.add(
types.InlineKeyboardButton(text=chat_name,
callback_data=dialog_id))
bot.send_message(tele_id, 'Contact:', reply_markup=keyboard)
else:
bot.send_message(tele_id, 'You are not authorized')
def get_token():
global app_id, phone, passwd, api, scope
auth_session = vk.AuthSession(app_id=app_id, user_login=phone, user_password=passwd, scope=scope)
access_token, _ = auth_session.get_access_token()
session = vk.Session(access_token=access_token)
api = vk.API(session, lang='ru')
return
def authentication(self):
session = vk.AuthSession(app_id=6463497,
user_login=self.user_login,
user_password=self.user_password,
scope="photos")
api = vk.API(session)
return api
def get_online_friends(login, password):
session = vk.AuthSession(app_id=APP_ID,
user_login=login,
user_password=password,
scope='friends')
api = vk.API(session, v=API_VERSION)
return api.users.get(user_ids=api.friends.getOnline())
def __init__(self, **kwargs):
self._MAX_POSTS_PER_QUERY = 100
self._config = kwargs
session = vk.AuthSession(app_id=self._config['app_id'],
user_login=self._config['login'],
user_password=self._config['password'])
self._api = vk.API(session, v='5.73', lang='ru')
def log_in():
session = vk.AuthSession(app_id=Settings.app_id,
user_login=Settings.login,
user_password=Settings.password,
scope='wall, photos')
api = vk.API(session)
return api
def get_auth_params_by_login_and_password(login_name, password):
try:
session = vk.AuthSession(STANDALONE_APP_ID, login_name, password)
api = vk.API(session, lang='en')
return session.get_access_token(), api.users.get()[0]['uid'], '0'
except:
return None, None, None
def pub_to_all(text: str, digest_url: str, digest_image_url: str):
"""
digest_url ='http://pythondigest.ru/issue/101/'
:param text:
:param digest_image_url:
:param digest_url:
:return:
"""
session = vk.AuthSession(app_id=settings.VK_APP_ID,
user_login=settings.VK_LOGIN,
user_password=settings.VK_PASSWORD,
scope='wall,messages')
api = vk.API(session)
twitter_text = 'Вот и свежий выпуск дайджеста новостей о #python. Приятного чтения: {0}'.format(
digest_url)
twitter_api = init_auth(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
settings.TWITTER_TOKEN,
settings.TWITTER_TOKEN_SECRET)
pub_to_slack(text, digest_url, digest_image_url, settings.IFTTT_MAKER_KEY)
pub_to_vk_groups(text, digest_url, api)
pub_to_telegram(text, settings.TGM_BOT_ACCESS_TOKEN, settings.TGM_CHANNEL)
pub_to_vk_users(text, api)
pub_to_gitter('\n'.join(text.split('\n')[1::]), settings.GITTER_TOKEN)
pub_to_twitter(twitter_text, digest_image_url, twitter_api)
def vk_graph(my_id=57573111):
appid = '5989878'
login = '******'
password = '******'
session = vk.AuthSession(appid, login, password, scope='friends')
vk_api = vk.API(session)
mygraph = MyGraph()
me = vk_api.users.get(user_ids=my_id, fields='city,photo_400_orig,domain')
mygraph.add_single_node(0, info=me)
my_friends_ids = vk_api.friends.get(user_id=my_id)
my_friends_full = vk_api.friends.get(user_id=my_id,
fields='city,photo_400_orig,domain')
active_friends = [my_id]
counter = 1
# print my_friends_full uncomment for info
for friend in my_friends_full:
if friend.get('deactivated') == None:
active_friends.append(friend.get('user_id'))
mygraph.add_single_node(active_friends.index(
friend.get('user_id')),
info=friend)
mutual = vk_api.friends.getMutual(source_uid=my_id,
target_uids=active_friends)
for m in mutual:
source = m.get('id')
source_id = active_friends.index(source)
print source_id
mygraph.add_single_edge(0, source_id, weight=1)
for target in m.get('common_friends'):
if target in active_friends:
target_id = active_friends.index(target)
mygraph.add_single_edge(source_id, target_id, weight=1)
return mygraph
