def auth():
scope = LAST_SCOPETS
if not USE_API_RELAY:
(token, uid, secret) = vk_auth.auth(LOGIN, PASS, APPID,
scope + ",nohttps")
agent = vkontakte.API(token=token, api_secret=secret)
else:
rsf = RELAY_SOCK_FILE
rsf.write('LOG1\n%s %s %s\n' % (LOGIN, PASS, APPID))
rsf.flush()
rsf.write(scope + '\n')
rsf.flush()
rld = rsf.readline().strip()
token, uid, secret = rld.split(' ')
agent = vkontakte.API()
return token, uid, secret, agent
def vkgrouppost(filename, text):
vk = vkontakte.API(token=VKTOKEN)
upurl = vk.get('photos.getWallUploadServer',gid=GROUPID)['upload_url']
r = requests.post(upurl, files={'photo': open(filename, 'rb')}).json()
ph = vk.get('photos.saveWallPhoto',server=r['server'],photo=r['photo'],hash=r['hash'],gid=GROUPID)
attach = ph[0]['id']
vk.get('wall.post',owner_id=0-GROUPID,message=text,attachments=attach,from_group=1)
def __init__(self, tok, log=1, loggerObject=None):
self.logFile2 = None
self.logFile2str = None
self.vk = vkontakte.API(token=tok)
self.__warmingUpCache()
self.logtxt = log
if loggerObject is None:
loggerObject = logger()
self.logger = loggerObject
from app.core.socialAnalyzer import socialAnalyze
from app.core.utilites import utilites
args = {
u'vk': self.vk,
u'logtxt': self.logtxt,
u'logger': self.logger,
u'cacheLogFile': self.cacheLogFile,
u'logFile2': self.logFile2,
u'logFile2str': self.logFile2str
}
args[u'api'] = vkapi(args)
self.api = vkapi(
args) #свои набор, для часто применяемых методов запросов к api vk
self.social = socialAnalyze(
args) #класс для социвального анализа в вк по теме
self.ut = utilites(args)
self.timeForLastRequest = time.time()
self.social.ut = self.ut
def handle(self, *args, **options):
vk = vkontakte.API(settings.VK_APP_ID, settings.VK_APP_SECRET)
for user in User.objects.all():
if user.is_vk_user():
vk_profile = user.vk_profile
new_data = vk.getProfiles(uids=str(user.username),
fields=','.join(FIELDS))[0]
for field in FIELDS:
if field == 'city':
try:
vk_profile.city = new_data[field]
except:
pass
elif field == 'country':
try:
vk_profile.country = new_data[field]
except:
pass
elif field == 'first_name' or field == 'last_name':
try:
setattr(user, field, new_data[field])
except:
pass
else:
try:
setattr(vk_profile, field, new_data[field])
except:
pass
vk_profile.save()
user.save()
print user.get_full_name()
time.sleep(0.34)
def fetch_friends(self, user):
"""
fethces friends from VKontakte using the access_token
fethched by django-social-auth.
Note - user isn't a user - it's a UserSocialAuth if using social auth, or a SocialAccount if using allauth
Returns:
collection of friend objects fetched from VKontakte
"""
if USING_ALLAUTH:
raise NotImplementedError(
"VKontakte support is not implemented for django-allauth")
#social_app = SocialApp.objects.get_current('vkontakte')
#oauth_token = SocialToken.objects.get(account=user, app=social_app).token
else:
social_auth_backend = VKOAuth2Backend()
# Get the access_token
tokens = social_auth_backend.tokens(user)
oauth_token = tokens['access_token']
api = vkontakte.API(token=oauth_token)
return api.get("friends.get")
def _patch_request_with_vkapi(self, request):
"""
Помещает в request.vk_api экземпляр vkontakte.API с настроенной
авторизацией.
"""
if use_vkontakte_pkg and hasattr(request, 'session'):
if 'vk_startup_vars' in request.session:
token = request.session['vk_startup_vars']['access_token']
request.vk_api = vkontakte.API(token=token)
def load_from_vkontakte(self, request, queryset):
import vkontakte
api = vkontakte.API(settings.VK_APP_ID,
settings.VK_APP_SECRET,
timeout=5)
cids = ','.join([str(city.pk) for city in queryset])
vk_data = api.getCities(cids=cids)
for item in vk_data:
city = City.objects.get(pk=item['cid'])
city.title = item['name']
city.save()
def get_api(used_access_tokens=None, *args, **kwargs):
'''
Return API instance with latest token from database
'''
if ACCESS_TOKEN:
token = ACCESS_TOKEN
else:
tokens = AccessToken.objects.filter_active_tokens_of_provider('vkontakte', *args, **kwargs)
if used_access_tokens:
tokens = tokens.exclude(access_token__in=used_access_tokens)
if len(tokens) == 0:
raise NoActiveTokens("There is no active AccessTokens with args %s and kwargs %s" % (args, kwargs))
else:
token = tokens[0].access_token
return vkontakte.API(token=token)
def session(sock, addr):
sock.send("\n")
cf = sock.makefile()
while 1:
c = cf.readline().strip()
if c == 'LOG1':
logstr = cf.readline().strip()
uid, passwd, appid = logstr.split(' ')
scope = cf.readline().strip()+',nohttps'
token, uid, secret = vk_auth.auth(uid, passwd, appid, scope)
cf.write('%s\n'%(' '.join((token, uid, secret))))
cf.flush()
vk_api = vkontakte.API(token=token, api_secret=secret)
elif c == 'REQE':
method = cf.readline().strip()
cf.write('OK\n')
cf.flush()
kwargs = {}
while 1:
c2 = cf.readline().strip()
if c2 == 'PARA':
key = cf.readline().strip()
leng = int(cf.readline().strip())
value = cf.read(leng).strip()
kwargs[key]=value
elif c2 == 'ENDP':
kwargs['method']=method
kwargs['raw']=1
resp = json.dumps(vk_api.__call__(**kwargs))
cf.write('ANSW\n')
cf.write('%d\n'%len(resp))
cf.write(resp)
cf.flush()
break
elif c == 'QUIT':
sock.close()
return
sock.close()
def get_connection_values(response, **kwargs):
if not response:
return None
access_token = response['access_token']
vk = vkontakte.API(token=access_token)
profile = vk.getProfiles(
uids=response['user_id'],
fields='first_name,last_name,photo_100,screen_name')[0]
profile_url = "http://vk.com/id%s" % response['user_id']
fullname = u'%s %s' % (profile['first_name'], profile['last_name'])
return dict(
provider_id=config['id'],
provider_user_id=str(profile['uid']),
access_token=access_token,
secret=None,
display_name=profile.get('screen_name', fullname),
full_name=fullname,
profile_url=profile_url,
image_url=profile.get('photo_100'),
email='',
)
__copyright__ = "Copyright 2013, GDG Omsk"
__email__ = "*****@*****.**"
__license__ = 'Apache License, Version 2.0'
__version__ = '0.1a'
import time
import webapp2
import vkontakte
from apiclient.discovery import build
import constants
import constants_secret
from model import CrossPostedToVK
plus = build('plus', 'v1', developerKey=constants_secret.GOOGLE_PLUS_API_KEY)
vk = vkontakte.API(token=constants_secret.VKONTAKTE_EKATERINA_LUBIMOVA_TOKEN)
class MainHandler(webapp2.RequestHandler):
""" Обработчик для кросс-постинга постов из g+ в вконтакте.
Учитываются только последние 20 постов. Каждый пост перепостчивается только один раз, независимо от кол-ва вызовов обработчика"""
def get(self):
response = self.fetch_last_posts()
self.cross_post_to_vk(response)
self.response.write("200 OK")
def fetch_last_posts(self):
request = plus.activities().list(userId=constants.GOOGLE_PLUS_GDG_OMSK_ID,
collection='public',
def test_timeout(self, post):
post.return_value = 200, '{"response":123}'
api = vkontakte.API(API_ID, API_SECRET, timeout=5)
res = api.getServerTime()
self.assertEqual(res, 123)
self.assertEqual(post.call_args[0][3], 5)
def setUp(self):
self.api = vkontakte.API(API_ID, API_SECRET)
def test_api_creation_error(self):
self.assertRaises(ValueError, lambda: vkontakte.API())
def vk(self):
"""VK api property"""
if not self._vk:
token = keyring.get_password('vkvideo-lens', 'access_token')
self._vk = vkontakte.API(token=token) if token else None
return self._vk
def Init():
vk = vkontakte.API('##id##', '###token####')
return vk
graph.add_edges_from(gd_accumulator['edges'])
# Disable profiling
if time_profiler:
time_profiler.disable()
return graph
DESCRIPTION = 'Get information about friends of user ' \
'with specified UID in social network vk.com'
TOKEN_VK = '2e27464b84d9a9833248daa69ac07ec4e9ef98a05' \
'1ad62dd18dc4a51513281a8de4249170a575d40f1332'
VK = vkontakte.API(token=TOKEN_VK)
DEFAULT_ATTRIBUTES = ['first_name', 'last_name', 'sex']
time_profiler = None
if __name__ == '__main__':
# set cli options
parser = argparse.ArgumentParser(description=DESCRIPTION)
parser.add_argument('uids',
metavar='UID',
type=int,
nargs='+',
help='UID of vk.com user.')
parser.add_argument('-w',
'--write-to',
import csv
import json
import vkontakte
# First, authenticate with app (see readme for reference)
with open('resources/token.json') as data_file:
data = json.load(data_file)
token = data['token']
vk = vkontakte.API(token=token)
# Some demo functions for debug
# print vk.getServerTime()
# var = vk.get('getProfiles', uids='1,2')
# var = vk.get('friends.get', fields='name')
# Method for working with russian text
def write_unicode(text, charset='utf-8'):
return text.encode(charset)
def get_friends_phones():
"""
This method gets the friends list of the user currently authenticated using API and stores it into
friends.csv file along with the friend's phone numbers.
:return:
"""
cont = vk.get('friends.get', fields='contacts')
f = csv.writer(open("friends.csv", "wb+"))
f.writerow(["name", "surname", "home_phone", "mobile"])
def main():
if (options.gid == None):
print "set group id ( use -h for help) "
exit(1)
if (options.email == None):
print "set Email ( use -h for help ) "
exit(1)
if (options.passwd == None):
options.passwd = getpass.getpass("Enter your password:"******"*" * len(options.passwd), options.app_id)
print greeting
(token, user_id) = vk_auth.auth(options.email, options.passwd,
options.app_id, 'friends')
vk = vkontakte.API(token=token)
server_time = vk.getServerTime() #check working
if (server_time):
group_info = groups_getById(vk, group_ids=options.gid)
name = group_info[0]["name"]
print "Auth is success, for ", name
try:
os.mkdir(FOLDER_RESULT +
name) # make the directory with the name of the publick
except (OSError):
print "Directory Exist"
ava = "ava.jpg"
vk_link = "vk_link.png"
vk_audio = "vk_audio.jpg"
vk_video = "vk_video.jpg"
shutil.copyfile(FOLDER_SERVICE + ava,
FOLDER_RESULT + "%s/%s" % (name, ava))
shutil.copyfile(FOLDER_SERVICE + vk_link,
FOLDER_RESULT + "%s/%s" % (name, vk_link))
shutil.copyfile(FOLDER_SERVICE + vk_video,
FOLDER_RESULT + "%s/%s" % (name, vk_video))
shutil.copyfile(FOLDER_SERVICE + vk_audio,
FOLDER_RESULT + "%s/%s" % (name, vk_audio))
if (options.count == None):
temp = get_posts(vk, -int(options.gid), 0, 1)
print "Post count = ", temp[0]
count = temp[0]
else:
count = int(options.count)
tom_count = int(options.split)
offset = int(
options.offset
) # frow where gell posts. This value will be chaged by iterations
posts_by_tom = count / tom_count
iteration = 0 #global iteration
curr_tom = 0
iteration = 1
tom_iteration = 0 # curr count of posts in current tom
step = 90
downloaded = 0
print posts_by_tom
name_tom = "%s_%i.html" % (name, curr_tom)
tom_file = open(FOLDER_RESULT + "%s/%s" % (name, name_tom),
'w+') # open first tom file
tom_file.write(page_begin.encode('utf-8'))
while (iteration * step < count):
if (tom_iteration * step >= posts_by_tom):
tom_file.close()
tom_iteration = 0
curr_tom += 1
name_tom = "%s_%i.html" % (name, curr_tom)
tom_file = open(FOLDER_RESULT + "%s/%s" % (name, name_tom),
'w+') # open cur tom file
tom_file.write(page_begin.encode('utf-8'))
posts = get_posts(vk, -int(options.gid), offset, step)
downloaded += len(posts) - 1
print "Скачано:", downloaded
posts_html = posts_to_html(vk, posts)
tom_file.write(posts_html.encode('utf-8'))
iteration += 1
tom_iteration += 1
offset += step
tom_file.close()
if (options.download_all == '1'):
for i in range(curr_tom + 1):
name_cur = "%s_%i.html" % (name, i)
long_name = FOLDER_RESULT + "%s/%s" % (name, name_cur)
folder = "%s_%sdata/" % (name, i)
long_folder = FOLDER_RESULT + "%s/%s" % (name, folder)
tom_file = codecs.open(long_name, "r", "utf-8")
converted = FOLDER_RESULT + "%s/%s_%s_converted.html" % (
name, name, i)
print converted
converted = open(converted, 'w+')
data = tom_file.read()
download_media(long_name,
FOLDER_RESULT + "%s/%s" % (name, folder))
new_data = convert_links(data, "./%s" % folder)
#tom_file.seek(0)
converted.write(new_data.encode("utf-8"))
tom_file.close()
converted.close()
return 0
def get_friends(user):
if user.is_vk_user():
vk = vkontakte.API(settings.VK_APP_ID, settings.VK_APP_SECRET)
friends = vk.friends.get(uid=user.username)
friends = map(str, friends)
return User.objects.filter(username__in=friends)
def get_api(connection, **kwargs):
return vkontakte.API(
api_id=kwargs.get('consumer_key'),
api_secret=kwargs.get('consumer_secret')
)
from django.template import RequestContext
from django.shortcuts import render_to_response
import vkontakte
from settings import APP_ID, APP2_ID, APP2_KEY, APP2_TOKEN, USER1_ID, USER2_ID
vk = vkontakte.API(APP_ID, token=APP2_TOKEN, timeout=5)
def home(request):
app_id = APP2_ID
settings = "friends"
my_friends = set(vk.friends.get(uid=USER1_ID))
my_requests = set(vk.friends.getRequests(uid=USER1_ID, out=1))
sempo_friends = set(vk.friends.get(uid=USER2_ID))
missing_friends = sempo_friends - (my_friends | my_requests)
print "Friends: %d" % len(my_friends)
print "Requests: %d" % len(my_requests)
print "Sempo friends: %d" % len(sempo_friends)
print "Common: %d" % len(missing_friends)
context = {
'app_id': app_id,
'settings': settings,
'friends': missing_friends,
}
return render_to_response("index.html",
context,
context_instance=RequestContext(request))
import httplib
import re
import vkontakte
import sys
sys.path.append('../../uglyweb/')
from uglyweb import settings
vk = vkontakte.API(settings.VK_ID, settings.VK_SECRET)
class ProfileNotFound(Exception):
def __init__(self, name):
self.name = name
super(ProfileNotFound, self).__init__()
def __repr__(self):
return 'Profile with data: %s not found!' % self.name
def get_profile(name):
"""Get profile from VK api"""
try:
return vk.getProfiles(uids=name,
fields='uid, first_name, last_name, photo, screen_name'
)[0]
except IndexError:
raise ProfileNotFound(name)
def check_url(addr, name):
"""Check url exist"""
def fill_db(db_name):
conn = sqlite3.connect(db_name)
c = conn.cursor()
try:
c.execute("""CREATE TABLE girls (
id integer primary key autoincrement,
name text,
city text,
age int,
link text,
likes int,
date int,
reply_count int,
reposts_count int,
parse_date int,
rating float,
page_url text
)
""")
c.execute("""CREATE TABLE photos (
id integer primary key autoincrement,
id_girl int,
url text,
likes int)
""")
except sqlite3.OperationalError:
pass
# vk = vkontakte.API(APP_ID, APP_SECRET)
vk = vkontakte.API(token=ACCESS_TOKEN)
offset = 0
girls_count = 0
date_now = int(time.time())
while True:
girls = vk.wall.get(owner_id='-37862023', offset=offset, count=100)
offset += 100
for _post in girls:
if not isinstance(_post, dict):
continue
girls_count += 1
# original post url
page_url = "http://vk.com/wall{}_{}".format(
_post['from_id'], _post['id'])
likes = _post['likes']['count']
date = int(_post['date'])
reply_count = int(_post['reply_count'])
reposts_count = int(_post['reposts']['count'])
post_text = _post['text']
# skip videos and another non-photo posts
try:
if _post['media']['type'] != u'photo':
continue
except KeyError as e:
log.info("Content type is {}".format(e))
# parse post text to fill db by additional info
# TODO: mb use regexp
name, city, age, link = 'None', 'None', 0, 'None'
_name, _br = post_text.find('Name:'), post_text.find('<br>')
if _name != -1 and _br != -1:
name = post_text[_name + 6:_br]
post_text = post_text[_br + 4:]
_city, _br = post_text.find('City:'), post_text.find('<br>')
if _city != -1 and _br != -1:
city = post_text[_city + 6:_br]
post_text = post_text[_br + 4:]
_age, _br = post_text.find('Age:'), post_text.find('<br>')
if _age != -1 and _br != -1:
try:
age = int(post_text[_age + 5:_br])
except Exception:
age = 0
post_text = post_text[_br + 4:]
_link = post_text.find('Link:')
if _link != -1:
link = post_text[_link + 6:]
# create girl rating
rating = float(likes + reply_count + reposts_count) * 10000
rating /= (date_now - date)
# fill db
c.execute("""UPDATE girls
SET age='%d', link='%s', likes='%d', date='%d',
reply_count='%d', reposts_count='%d',
parse_date='%d', rating='%.2f'
WHERE page_url='%s'
""" % (age, link, likes, date, reply_count,
reposts_count, date_now, rating, page_url))
# if update was successfull rowcount != 0
# if rowcount == 0 then there is no girl from the 'page_url'
if c.rowcount == 0:
c.execute("""INSERT INTO girls
(name, city, age, link, likes, date,
reply_count, reposts_count, parse_date,
rating, page_url)
VALUES ('%s', '%s', '%d', '%s', '%d',
'%d', '%d', '%d', '%d', '%.2f', '%s')
""" %
(name, city, age, link, likes, date, reply_count,
reposts_count, date_now, rating, page_url))
log.info("Girl was added to the db")
else:
log.info("Girls info was updated")
girls_id = c.lastrowid
# if girls_id is None - girl info was updated
# lets think that there are no new photos in updates
if girls_id:
try:
for _photo in _post['attachments']:
photo = 'None'
try:
photo = _photo['photo']['src_big']
photo = _photo['photo']['src_xbig']
photo = _photo['photo']['src_xxbig']
except KeyError as exception:
log.warning(
"Girl ID: {}. There is no {} type".format(
girls_id, exception))
c.execute("""INSERT INTO photos (id_girl, url, likes)
VALUES (%d, '%s', %d)
""" % (girls_id, photo, likes))
except KeyError as e:
log.warning(
"KeyError: there is no {} for this post".format(e))
conn.commit()
if offset > girls[0]:
break
time.sleep(2.0)
c.close()
