def getMyId(self):
try:
api = InstagramAPI(access_token=self._accessToken)
self.myId = api.user().id
except:
return None
return self.myId
class InstagramUtils(object):
INSTAGRAM_CLIENT_ID = '38079a9f3f054e3da845e0e7e6202e18'
INSTAGRAM_CLIENT_SECRET = 'f933e5ecc3504d1498f4a5bf6a0c0b74'
def __init__(self):
self.api = InstagramAPI(client_id=InstagramUtils.INSTAGRAM_CLIENT_ID,
client_secret=InstagramUtils.INSTAGRAM_CLIENT_SECRET)
def get_user_by_username(self, username):
users = self.api.user_search(q=username)
users = filter(lambda user: user.username == username, users)
if users:
return users[0]
else:
return None
def get_user_page(self, username):
return 'https://instagram.com/%s/' % username
def load_user_feed(self, user_id, **kwargs):
try:
feed, next_url = self.api.user_recent_media(user_id=user_id, **kwargs)
except InstagramAPIError as e:
feed = None
return feed
def main(configFile=None):
''' Deletes all subscriptions from the Instagram server. Typically called
on a new dotcloud push just to make sure its all clear.'''
print "----------->", configFile
# Get the config information into a single object
p = getConfigParameters(configFile)
# Get the client and secret keys
api = InstagramAPI(client_id=p.client, client_secret=p.secret)
# Get all current subs
subs = api.list_subscriptions()
# For each active sub, delete it
if subs['meta']['code'] == 200:
for sub in subs['data']:
if sub['type'] == 'subscription':
deleted = api.delete_subscriptions(id=int(sub['id']))
# Final check - make sure they're definitely all gone
subs = api.list_subscriptions()
if len(subs['data']) == 0:
success = True
else:
success = False
else:
success = False
def ageOffSubscriptions(p, collHandle, ageOff, protectedSubs):
''' Deletes subscriptions from the Instagram server based on the age and protection level
in the subs collection. If protect=True, then it must be manually deleted'''
out = []
# Get the client and secret keys
api = InstagramAPI(client_id=p.client, client_secret=p.secret)
# Get the expired non-protected subscriptions
subs, ids = getExpiredSubs(collHandle, ageOff, protectedSubs)
# Delete the subscriptions from the instagram server
for sub in subs:
print sub
deleted = api.delete_subscriptions(id=int(sub))
print deleted
out.append(deleted)
if deleted['meta']['code'] != 200:
print 'Failed to delete subscription %s' %(sub)
# Delete the nextUrl object files (kept in the config directory)
for objId in ids:
f = os.path.join(os.path.dirname(p.configFile), objId)
try:
os.remove(f)
except:
print 'Failed to delete the subscription next URL file: \n %s\n' %(f)
return out
def get_photos(max_tag_id=None):
api = InstagramAPI(client_id=g.instagram_id,
client_secret=g.instagram_secret,
redirect_uri='http://www.gummiognina.com/')
data, next_url = api.tag_recent_media(tag_name=TAG_NAME,
count=PAGE_COUNT,
max_tag_id=max_tag_id)
def _to_dict(obj):
d = dict()
if not isinstance(obj, dict):
obj = obj.__dict__
for key, value in obj.iteritems():
if isinstance(value, (ApiModel, dict)):
d[key] = _to_dict(value)
elif isinstance(value, list):
d[key] = map(unicode, value)
else:
d[key] = unicode(value)
return d
def yield_images():
for obj in data:
yield _to_dict(obj)
qs = urlparse(next_url).query
max_tag_id = parse_qs(qs).get('max_tag_id', [None])[0]
return (_to_dict(obj) for obj in data), max_tag_id
def subscription(request):
print request
if request.method == 'GET':
challenge = request.GET['hub.challenge']
return HttpResponse(challenge)
elif request.method == 'POST':
subscription_objects = json.loads(request.body)
api = InstagramAPI(client_id=INSTAGRAM_CLIENT_ID, client_secret=INSTAGRAM_CLIENT_SECRET)
for obj in subscription_objects:
try:
photo = api.media(obj['object_id'])
parse_photo = ParsePy.ParseObject("instagram_photo")
parse_photo.url = photo.images['standard_resolution'].url
parse_photo.url_thumb = photo.images['thumbnail'].url
parse_photo.timestamp = photo.created_time
likes = []
for user in photo.likes:
likes.append(parse_user_from_instagram(user))
parse_photo.likes = likes;
comments = []
for comment in photo.comments:
comments.appent(parse_comment_from_instagram(comment))
parse_photo.comments(comments)
parse_photo.location = parse_location_from_instagram(photo.location)
parse_photo.save()
except AttributeError:
pass
print request
def main(configFile=None):
''' Deletes all subscriptions from the Instagram server. Typically called
on a new dotcloud push just to make sure its all clear.'''
print "----------->", configFile
# Get the config information into a single object
p = getConfigParameters(configFile)
# Get the client and secret keys
api = InstagramAPI(client_id=p.client, client_secret=p.secret)
# Get all current subs
subs = api.list_subscriptions()
# For each active sub, delete it
if subs['meta']['code'] == 200:
for sub in subs['data']:
if sub['type'] == 'subscription':
deleted = api.delete_subscriptions(id=int(sub['id']))
# Final check - make sure they're definitely all gone
subs = api.list_subscriptions()
if len(subs['data']) == 0:
success = True
else:
success = False
else:
success = False
def isfollow(uid, api=None):
if not api:
api = InstagramAPI(access_token=session.get('access_token', ''))
data = api.user_relationship(user_id=uid)
if data.outgoing_status == 'follows':
return True
return False
def ageOffSubscriptions(p, collHandle, ageOff, protectedSubs):
''' Deletes subscriptions from the Instagram server based on the age and protection level
in the subs collection. If protect=True, then it must be manually deleted'''
out = []
# Get the client and secret keys
api = InstagramAPI(client_id=p.client, client_secret=p.secret)
# Get the expired non-protected subscriptions
subs, ids = getExpiredSubs(collHandle, ageOff, protectedSubs)
# Delete the subscriptions from the instagram server
for sub in subs:
print sub
deleted = api.delete_subscriptions(id=int(sub))
print deleted
out.append(deleted)
if deleted['meta']['code'] != 200:
print 'Failed to delete subscription %s' % (sub)
# Delete the nextUrl object files (kept in the config directory)
for objId in ids:
f = os.path.join(os.path.dirname(p.configFile), objId)
try:
os.remove(f)
except:
print 'Failed to delete the subscription next URL file: \n %s\n' % (
f)
return out
def get(self):
if has_login():
return redirect(url_for('views.home'))
redirect_url = url_for('views.home')
code = request.args.get('code', '')
redirect_uri = INSTAGRAM_REDIRECT_URI
if request.args.get('uri', ''):
redirect_url = request.args.get('uri')
redirect_uri += '?uri=' + redirect_url
api = InstagramAPI(client_id=INSTAGRAM_CLIENT_ID,
client_secret=INSTAGRAM_CLIENT_SECRET,
redirect_uri=redirect_uri)
try:
access_token = api.exchange_code_for_access_token(code)
print access_token
except:
return InternalServerError(u'InternalServerError')
user = (User.query
.filter_by(id=access_token[1]['id']).first())
if user:
user.update(access_token=access_token[0],
name=access_token[1]['username'],
avatar=access_token[1]['profile_picture'])
else:
user = User.create(id=access_token[1]['id'],
name=access_token[1]['username'],
avatar=access_token[1]['profile_picture'],
access_token=access_token[0])
redirect_url = url_for('views.welcome')
session.permanent = True
session['uid'] = user.id
session['username'] = user.name
session['access_token'] = user.access_token
return redirect(redirect_url)
def list(tag):
api = InstagramAPI(client_id=CLIENT_ID)
items, next = api.tag_recent_media(count=12, tag_name=tag)
if is_nonmobile(request.environ):
return render_template("_item.html", items=items)
else:
return render_template("_mitem.html", items=items)
def isfollow(ukey, api=None):
if not api:
api = InstagramAPI(access_token=session.get('access_token', ''))
data = api.user_relationship(user_id=ukey)
outgoing = data.outgoing_status
if outgoing == 'follows':
return True
return False
def get_posts(user_social_auth, last_updated_time):
api = InstagramAPI(
access_token=user_social_auth.extra_data['access_token'])
formatted_time = helper.datetime_to_timestamp(
last_updated_time) if last_updated_time else None
recent_media, next_ = api.user_recent_media(
user_id=user_social_auth.uid, min_timestamp=formatted_time)
return recent_media
def post(self, mid):
api = InstagramAPI(access_token=request.access_token)
form = MediaCommentForm()
if not form.validate():
media_info = self._get_media(api, mid)
return render('media.html', form=form, **media_info)
api.create_media_comment(media_id=mid, text=form.content.data)
media_info = self._get_media(api, mid)
return render('media.html', form=form, **media_info)
def get_user(uid, access_token):
try:
api = InstagramAPI(access_token=access_token)
user = api.user(uid)
return user
except InstagramAPIError, e:
if e.error_type in ['APINotAllowedError-you', 'APINotFoundError-this']:
delete_worker(uid)
print e.error_type
return e
def process_instagram_update(update):
subscription_id = update.get('subscription_id')
subscription = Subscription.objects.filter(
subscription_id=subscription_id).first()
if not subscription:
return
api = InstagramAPI(
client_id=subscription.config.get('app_id'),
client_secret=subscription.config.get('app_secret'))
tag = update['object_id']
media, next = api.tag_recent_media(30, 0, tag)
for image in media:
post, created = Post.objects.get_or_create(
subscription=subscription,
source_id=image.id,
created_at=image.created_time.replace(tzinfo=pytz.utc)
)
if not created:
continue
post.data = {
'filter': image.filter,
'link': image.link,
'type': image.type,
'tags': [t.name for t in image.tags],
'user': {
'id': image.user.id,
'username': image.user.username,
'full_name': image.user.full_name,
'profile_picture': image.user.profile_picture,
'website': image.user.website,
'bio': image.user.bio,
},
'images': {
'thumbnail': image.get_thumbnail_url(),
'small': image.get_low_resolution_url(),
'default': image.get_standard_resolution_url(),
}
}
if getattr(image, 'caption', None):
post.data['caption'] = image.caption.text
if getattr(image, 'location', None) \
and getattr(image.location, 'point', None):
post.data['location'] = {
'latitude': image.location.point.latitude,
'longitude': image.location.point.longitude,
}
post.save()
def isTokenValid(self):
try:
api = InstagramAPI(access_token=self._accessToken)
api.user()
except InstagramAPIError as e:
return ErrorCode.E_INVALID_TOKEN
except:
self._logger.exception('InstaBase::isTokenValid() exception')
return ErrorCode.E_FAILED
else:
return ErrorCode.S_OK
def get_user(uid, access_token):
try:
api = InstagramAPI(access_token=access_token)
user = api.user(uid)
return user
except InstagramAPIError, e:
if e.error_type in ['APINotAllowedError-you',
'APINotFoundError-this']:
delete_worker(uid)
print e.error_type
return e
def get(self):
mid = request.args.get('mid', '')
ukey = session.get('ukey', '')
api = InstagramAPI(access_token=session.get('access_token', ''))
likes = api.media_likes(media_id=mid)
ret = False
for i in likes:
if ukey == i.id:
ret = True
break
return json_response(ret)
def get(self):
action = request.args.get('action', 'create_comment')
mid = request.args.get('mid', '')
text = request.args.get('text', '')
api = InstagramAPI(access_token=session.get('access_token', ''))
if action == 'create_comment':
api.create_media_comment(media_id=mid, text=text)
elif action == 'delete_comment':
cid = request.args.get('comment_id', '')
api.delete_comment(media_id=mid, comment_id=cid)
return json_response('ok')
def get(self):
if has_login():
return redirect(url_for('views.welcome'))
redirect_uri = INSTAGRAM_REDIRECT_URI
if request.args.get('uri', ''):
redirect_uri += '?uri=' + request.args.get('uri')
api = InstagramAPI(client_id=INSTAGRAM_CLIENT_ID,
client_secret=INSTAGRAM_CLIENT_SECRET,
redirect_uri=redirect_uri)
try:
redirect_uri = api.get_authorize_login_url(scope=INSTAGRAM_SCOPE)
except InstagramAPIError:
return InternalServerError(u'Server Error')
return redirect(redirect_uri)
def refresh_user_pic():
users = UserModel.query.all()
for user in users:
print user
try:
ret = urllib.urlopen(user.pic)
if ret.code != 200:
print 'refresh!'
api = InstagramAPI(access_token=user.access_token)
new = api.user(user_id=user.ukey)
user.pic = new.profile_picture
except Exception:
pass
db.session.commit()
def get_item(instagram_id):
api = InstagramAPI(client_id='f7a905471d5c4f29a8f6797c83499bb6')
media = api.media(instagram_id)
item = Item()
item.link = media.link
if(type(media.caption) is not NoneType):
item.caption = media.caption.text
item.image_url = media.images['standard_resolution'].url
item.thumbnail_url = media.images['thumbnail'].url
item.user_name = media.user.username
item.user_profile_url = media.user.profile_picture
item.create_time = media.created_time
return item
def photos(request, code=None):
code = request.GET.get('code', None)
client_id = settings.INSTAGRAM_CLIENT_ID
client_secret = settings.INSTAGRAM_CLIENT_SECRET
redirect_uri = settings.INSTAGRAM_REDIRECT_URI
api = InstagramAPI(client_id=client_id, client_secret=client_secret,
redirect_uri=redirect_uri)
if not code:
redirect_url = api.get_authorize_login_url()
return redirect(redirect_url)
access_token = api.exchange_code_for_access_token(code)
api = InstagramAPI(access_token=access_token[0])
media = api.user_recent_media(user_id=access_token[1]['id'], count=10)
# create the base dir for all the downloads
if not os.path.exists(settings.BASE_PHOTOS_DIR):
os.makedirs(settings.BASE_PHOTOS_DIR)
user_dir = os.path.join(settings.BASE_PHOTOS_DIR, access_token[1]['username'])
if not os.path.exists(user_dir):
os.makedirs(user_dir)
os.chdir(user_dir)
metadata = []
for md in media[0]:
if not md.type == 'image':
continue
url = md.get_standard_resolution_url()
filename = url.split('/')[-1]
try:
f = open(filename,'wb')
f.write(urllib.urlopen(url).read())
f.close()
metadata.append({
'filename': filename,
'url': url,
'created_time': str(md.created_time),
'caption': md.caption
})
except IOError as e:
print e.message
with open('metadata.json', 'w+') as fp:
json.dump(metadata, fp)
return HttpResponse('<h3>Your photos have been downloaded to %s !<h3>' % user_dir)
def get_instub_feed(access_token, min_id=None):
print min_id
try:
api = InstagramAPI(access_token=access_token)
medias_list = []
next_ = True
while next_:
next_url = None if next_ is True else next_
medias, next_ = api.user_media_feed(with_next_url=next_url,
min_id=min_id)
medias_list.extend(medias)
return medias_list
except InstagramAPIError, e:
if e.error_type in ['APINotAllowedError-you', 'APINotFoundError-this']:
pass
return []
def post(self):
access_token = random.choice(OPEN_ACCESS_TOKENS)
api = InstagramAPI(access_token=access_token)
next_url = None
done = False
while not done:
medias = api.tag_recent_media(tag_name='zhinsta',
with_next_url=next_url)
next_url = medias[1]
for m in medias[0]:
tmp = add_show(m)
if tmp:
done = True
if not next_url:
break
return 'ok'
def get(self, id):
api = InstagramAPI(access_token=request.access_token)
media, likes = self._get_meida(id, api)
errors = self._get_errors(media, likes, id)
if errors:
return errors
uid = media.user.id
is_follow = False
if request.uid:
try:
is_follow = isfollow(uid, api)
except InstagramAPIError:
return InternalServerError('Internal server error')
media_user = self._get_media_user(uid, api)
if not media_user:
return InternalServerError('Internal server error')
is_star = False
for i in likes:
if request.uid and request.uid == i.id:
is_star = True
return render_template('media.html',
media=media,
isfollow=is_follow,
media_user=media_user,
likes=likes[:5],
is_star=is_star)
def get_api(self):
if not hasattr(self, '_api'):
self._api = InstagramAPI(
client_id=settings.CONNECTED_ACCOUNTS_INSTAGRAM_CONSUMER_KEY,
client_secret=settings.CONNECTED_ACCOUNTS_INSTAGRAM_CONSUMER_SECRET,
access_token=self.account.get_token())
return self._api
def complete(request):
code = request.GET['code']
access_token = api.exchange_code_for_access_token(code)
auth_api = InstagramAPI(access_token=access_token[0])
user, _ = User.objects.get_or_create(
username=access_token[1].get('username')
)
# Don't repeat this!
user.backend = 'django.contrib.auth.backends.ModelBackend'
#authenticate(username=user.username, password=user.password)
login(request, user)
# Move to worker
recent_media, _ = auth_api.user_recent_media(count=0)
for media in recent_media:
photo, created = Photo.objects.get_or_create(
user=user,
instagram_id=media.id
)
if created:
img_temp = NamedTemporaryFile(delete=True)
with img_temp:
request = requests.get(
media.images['standard_resolution'].url,
stream=True
)
for block in request.iter_content(1024):
if not block:
break
img_temp.write(block)
img_temp.flush()
photo.image.save(
'{}.jpg'.format(photo.instagram_id),
File(img_temp)
)
image_path = photo.image.path
valid_faces = detect_faces(image_path)
for face in valid_faces:
face_image_path = make_face_images(image_path, face)
with open(face_image_path):
face = Face.objects.create(
user=user,
photo=photo,
)
face.image.name = face_image_path
face.save()
return redirect('choose')
def get(self):
action = request.args.get('action', 'follow')
ukey = request.args.get('ukey', '')
api = InstagramAPI(access_token=session.get('access_token', ''))
if action == 'follow':
api.follow_user(user_id=ukey)
m = FollowModel(ukey=session.get('ukey', ''),
follow_ukey=ukey,
username=session.get('username', ''))
db.session.add(m)
if action == 'unfollow':
api.unfollow_user(user_id=ukey)
m = FollowModel.query.get((session.get('ukey', ''), ukey))
if m:
db.session.delete(m)
db.session.commit()
return json_response('ok')
def get_instub_feed(access_token, min_id=None):
print min_id
try:
api = InstagramAPI(access_token=access_token)
medias_list = []
next_ = True
while next_:
next_url = None if next_ is True else next_
medias, next_ = api.user_media_feed(with_next_url=next_url,
min_id=min_id)
medias_list.extend(medias)
return medias_list
except InstagramAPIError, e:
if e.error_type in ['APINotAllowedError-you',
'APINotFoundError-this']:
pass
return []
def get_api(self, request):
if not hasattr(self, '_api'):
rel_to = self.model._meta.get_field('account').rel.to
connected_account = get_object_or_404(rel_to, pk=request.GET.get('account'))
self._api = InstagramAPI(
client_id=settings.CONNECTED_ACCOUNTS_INSTAGRAM_CONSUMER_KEY,
client_secret=settings.CONNECTED_ACCOUNTS_INSTAGRAM_CONSUMER_SECRET,
access_token=connected_account.get_token())
return self._api
def __init__(self, token, ip, secret, tag_list, log=None, pause=None):
"""
:param token: Access_token of account
:param ip: Machines IP
:param secret: Client secret
:param tag_list: List of hastags to interact with
:param log: Where to save info. Default "instabot.log"
:param pause: Time to wait before interacting again. Default 1 second"
"""
super(InstaBot, self).__init__()
self.api = InstagramAPI(access_token=token, client_ips=ip,
client_secret=secret)
self.tag_list = tag_list
self.log = "instabot.log" if log is None else log
self.pause = 1 if pause is None else pause
self.db = DB()
self.__count = 0
def get(self):
likes = (LikeModel.query
.filter(LikeModel.ukey == '448621019')
.order_by(LikeModel.date_created.desc())
.limit(5).all())
access_token = random.choice(OPEN_ACCESS_TOKENS)
api = InstagramAPI(access_token=access_token)
media = api.media(likes[0].media)
if isinstance(media, InstagramAPIError):
return notfound(u'服务器暂时出问题了')
medias = ShowModel.query.filter(
ShowModel.mid.in_([x.media for x in likes[1:]]))
users = (RecommendModel.query
.order_by(RecommendModel.order.desc())
.limit(24).all())
return render('home.html',
media=media,
medias=medias,
users=users)
def get(self, name):
next_url = request.args.get('next_url', None)
api = InstagramAPI(access_token=request.access_token)
tag = api.tag(name)
media = api.tag_recent_media(tag_name=name,
with_next_url=next_url)
tag = gevent.spawn(api.tag, name)
media = gevent.spawn(api.tag_recent_media,
tag_name=name, with_next_url=next_url)
gevent.joinall([tag, media])
try:
tag, media = tag.get(), media.get()
except InstagramAPIError:
return notfound(u'服务器暂时出问题了')
next_url = media[1]
media = media[0]
return render('tag.html', tag=tag, media=media, next_url=next_url)
def _authenticate(self, user):
try:
social_auth = user.social_auth.get(provider='instagram')
token_key = social_auth.extra_data['access_token']
except (ObjectDoesNotExist, KeyError):
raise CredentialsNotFound('instagram', user)
return InstagramAPI(
client_secret=settings.SOCIAL_AUTH_INSTAGRAM_SECRET,
access_token=token_key)
def get_medias(uid, access_token, min_id=None):
print uid, access_token, min_id
try:
api = InstagramAPI(access_token=access_token)
medias_list = []
next_ = True
while next_:
next_url = None if next_ is True else next_
medias, next_ = api.user_recent_media(user_id=uid,
with_next_url=next_url,
min_id=min_id)
medias_list.extend(medias)
print len(medias_list)
return medias_list
except InstagramAPIError, e:
if e.error_type in ['APINotAllowedError-you', 'APINotFoundError-this']:
delete_worker(uid)
print e.error_type
return e
def get_medias(uid, access_token, min_id=None):
print uid, access_token, min_id
try:
api = InstagramAPI(access_token=access_token)
medias_list = []
next_ = True
while next_:
next_url = None if next_ is True else next_
medias, next_ = api.user_recent_media(
user_id=uid, with_next_url=next_url,
min_id=min_id)
medias_list.extend(medias)
print len(medias_list)
return medias_list
except InstagramAPIError, e:
if e.error_type in ['APINotAllowedError-you',
'APINotFoundError-this']:
delete_worker(uid)
print e.error_type
return e
def get(self, name):
next_url = request.args.get('next_url', None)
api = InstagramAPI(access_token=request.access_token)
tag = api.tag(name)
media = api.tag_recent_media(tag_name=name,
with_next_url=next_url)
tag = gevent.spawn(api.tag, name)
media = gevent.spawn(api.tag_recent_media,
tag_name=name, with_next_url=next_url)
gevent.joinall([tag, media])
try:
tag, media = tag.get(), media.get()
except InstagramAPIError:
return InternalServerError('Internal server error')
next_url = media[1]
media = media[0]
pager = Pager(tag.media_count)
return render_template('tag.html', tag=tag, pager=pager,
media=media, next_url=next_url)
def get(self):
if has_login():
return redirect(url_for('view.show'))
redirect_url = url_for('view.show')
code = request.args.get('code', '')
redirect_uri = INSTAGRAM_REDIRECT_URI
if request.args.get('uri', ''):
redirect_url = request.args.get('uri')
redirect_uri += '?uri=' + redirect_url
api = InstagramAPI(client_id=INSTAGRAM_CLIENT_ID,
client_secret=INSTAGRAM_CLIENT_SECRET,
redirect_uri=redirect_uri)
try:
access_token = api.exchange_code_for_access_token(code)
except:
return apierror()
user = (UserModel.query
.filter_by(ukey=access_token[1]['id']).first())
if user:
user.access_token = access_token[0]
user.username = access_token[1]['username']
user.pic = access_token[1]['profile_picture']
else:
user = UserModel(ukey=access_token[1]['id'],
username=access_token[1]['username'],
pic=access_token[1]['profile_picture'],
access_token=access_token[0])
db.session.add(user)
redirect_url = url_for('view.welcome')
db.session.commit()
admin = AdminModel.query.get(user.ukey)
session.permanent = True
session['ukey'] = user.ukey
session['username'] = user.username
session['access_token'] = user.access_token
session['is_admin'] = True if admin else False
return redirect(redirect_url)
class MuslimahGalau(Instapy):
instagram = InstagramAPI(access_token=ACCESS_TOKEN,
client_secret=CLIENT_SECRET)
insta_post = InstagramSession(
username=USERNAME,
password=PASSWORD,
guid='3efc0996-85bd-11e5-857d-74de2b6b05c3',
device_id='android-3efc0996-85bd-11e5-857d-74de2b6b05c3',
user_agent=
'Instagram 4.2.2 Android (10/1.5.2; 120; 480x800; samsung; GT-N7000; GT-N7000; smdkc210; en_US)'
)
user_followed = USERS
tags = [
'#muslimahgalau', '#muslimah', '#galau', '#akhowat', '#akhwat',
'#tausiyah'
]
IMAGES_PATH = '/home/ramdani/projects/auto-repost/muslimah_images/'
def get(self, uid=None):
next_url = request.args.get('next_url', None)
if next_url and 'instagram' not in next_url:
next_url = signer.loads(next_url)
api = InstagramAPI(access_token=request.access_token)
user = gevent.spawn(wrap_errors(InstagramAPIError, api.user),
user_id=uid)
feeds = gevent.spawn(wrap_errors(InstagramAPIError,
api.user_recent_media),
user_id=uid,
with_next_url=next_url)
if request.uid:
isfollows = spawn(isfollow, uid, api)
else:
isfollows = spawn(lambda x: False, uid)
gevent.joinall([user, feeds, isfollows])
user, feeds, isfollows = user.get(), feeds.get(), isfollows.get()
errors = [
e for e in (user, feeds, isfollows)
if isinstance(e, InstagramAPIError)
]
if errors:
if any([e.error_type == 'APINotAllowedError' for e in errors]):
return render_template('profile-noauth.html', uid=uid)
if any([e.error_type == 'APINotFoundError' for e in errors]):
return NotFound(u'User Not Found')
return InternalServerError('Internal Server Error')
next_url = feeds[1] if feeds else None
next_url = signer.dumps(next_url) if next_url else next_url
feeds = feeds[0] if feeds else []
isme = False
if request.uid and uid == request.uid:
isme = True
return render_template('profile.html',
user=user,
feeds=feeds,
isme=isme,
isfollow=isfollows,
next_url=next_url)
def _get_users(self, uid, user_type='followed'):
next_url = request.args.get('next_url', None)
if next_url and 'instagram' not in next_url:
next_url = signer.loads(next_url)
api = InstagramAPI(access_token=request.access_token)
user = spawn(api.user, uid)
if user_type == 'following':
users = spawn(api.user_follows, uid, with_next_url=next_url)
else:
users = spawn(api.user_followed_by, uid, with_next_url=next_url)
isfollows = False
if request.uid:
isfollows = spawn(isfollow, uid, api)
else:
isfollows = spawn(lambda x: False, uid)
gevent.joinall([user, users, isfollows])
user, users, isfollows = user.get(), users.get(), isfollows.get()
errors = get_errors(user, users, isfollows)
if errors:
return InternalServerError('Internal Server Error')
next_url = users[1]
next_url = signer.dumps(next_url) if next_url else next_url
users = users[0]
isme = False
if request.uid and uid == request.uid:
isme = True
context = {
'user': user,
'users': users,
'next_url': next_url,
'isfollows': isfollows,
'isme': isme,
}
return context
def get(self):
action = request.args.get('action', 'like')
mid = request.args.get('mid', '')
api = InstagramAPI(access_token=session.get('access_token', ''))
if action == 'like':
api.like_media(media_id=mid)
media = api.media(mid)
m = LikeModel(ukey=session.get('ukey', ''), media=mid,
username=session.get('username', ''),
media_username=media.user.username)
db.session.add(m)
add_show(media)
if action == 'unlike':
api.unlike_media(media_id=mid)
m = LikeModel.query.get((session.get('ukey', ''), mid))
if m:
db.session.delete(m)
db.session.commit()
return json_response('ok')
import networkx as nx
from bottle import *
picked_pic_db = 'db_nnpicks.txt'
picked_pic_db_backup = 'db_nnpicks.txt.backup'
picked_pic_db_debug = 'db_nnpicks_debug.txt'
good_users_db = 'db_good_users.txt'
good_users_db_debug = 'db_good_users_debug.txt'
great_pics_db = "db_great_pics.txt"
great_pics_db_debug = "db_great_pics_debug.txt"
network_db = 'db_network.txt'
network_db_backup = 'db_network.txt.backup'
network_db_debug = 'db_network_debug.txt'
access_token = '1529897738.2d6fe64.87556684de0d4ce1aa6afbf423a8cada'
api = InstagramAPI(access_token=access_token)
HOST = 'localhost'
debug_mode = 0
first_run = False
try:
shutil.copyfile(picked_pic_db, picked_pic_db_backup)
except:
print("Error during backup. Exiting.")
print("*** Remaining API Calls = %s/%s" %
(api.x_ratelimit_remaining, api.x_ratelimit))
sys.exit(0)
menu = {}
menu["HOME"] = "/"
menu["GOOD USERS"] = "/good-users"
def item(id):
api = InstagramAPI(client_id=CLIENT_ID)
item = api.media(media_id=id)
return render_template("_mimage.html", item=item)
from __future__ import print_function
from __future__ import division
from instagram import client, subscriptions, InstagramAPI
import sys
from datetime import date, timedelta
import json
import time
import datetime
import shutil
import operator
from pylab import *
import math
access_token = '1529897738.2d6fe64.87556684de0d4ce1aa6afbf423a8cada'
api = InstagramAPI(access_token=access_token)
debug_mode = 0
first_run = False
picked_pic_db = 'db_nnpicks.txt'
picked_pic_db_backup = 'db_nnpicks.txt.backup'
picked_pic_db_debug = 'db_nnpicks_debug.txt'
good_users_db = 'db_good_users.txt'
good_users_db_debug = 'db_good_users_debug.txt'
report_file = "nnreport.html"
try:
shutil.copyfile(picked_pic_db, picked_pic_db_backup)
except:
print("Error during backup. Exiting.")
print("*** Remaining API Calls = %s/%s" %
(api.x_ratelimit_remaining, api.x_ratelimit))
def getData(self, since=None, until=None):
"""
Get data from Instagram feed
In:
since -- The start time to get data
given None means current time
or given python's datetime instance as input
until -- The end time to get date
given None means yesterday
or given python's datetime instance as input
Example: (Please note that the direction to retrieve data is backward)
Now ---> 2012/04/01 ---> 2012/01/01
You can specify since=None and until=<datetime of 2012/01/01>
or since=<datetime of 2012/04/01> until=<datetime of 2012/01/01>
Out:
Return a python dict object
{
'data': { # List of data
'id': {
'id': 'postId',
'message': 'Text',
'photos': [ '/path/to/file' ],
'createdTime': <datetime object>,
'place': { # *optional*
'id': 'locationId',
'name': 'locationName',
'latitude': nnn.nnn,
'longitude' mmm.mmm
}
}, ...
},
'count': 30, # count in data dic
'retCode': ErrorCode.S_OK, # returned code which is instance of ErrorCode
}
"""
retDict = {
'retCode': ErrorCode.E_FAILED,
'count': 0,
'data': {},
}
if not until:
until = datetime.now() - timedelta(1)
tokenValidRet = self.isTokenValid()
if ErrorCode.IS_FAILED(tokenValidRet):
retDict['retCode'] = tokenValidRet
return retDict
if not self.myId:
return retDict
sinceTimestamp = self._datetime2Timestamp(since) + 1 if since else None
untilTimestamp = self._datetime2Timestamp(until) - 1 if until else None
api = InstagramAPI(access_token=self._accessToken)
for media in api.user_recent_media(max_pages=999,
min_timestamp=untilTimestamp,
max_timestamp=sinceTimestamp):
if not media:
break
for data in media:
data = self._transformFormat(data)
self._dumpData(data)
retDict['data'][data['id']] = data
retDict['count'] = len(retDict['data'])
retDict['retCode'] = ErrorCode.S_OK
return retDict
from instagram import InstagramAPI
import io
api = InstagramAPI(client_id='CLIENT_ID', client_secret='CLIENT_SECRET')
log = io.open(r'InstagramFolder/instagram.txt', 'wb')
hashtags = ['pizza', 'cheese'] #add as many search terms you need here
lat = 38.907192
long = -77.036871
dist = 1000 #in meters
# Search location by long+lat
def search_by_lat_long(latitude, longitude, distance):
media_search = api.media_search(lat=latitude,
lng=longitude,
distance=distance)
for media in media_search:
log.write(u'\n--&&&***--')
log.write(media.user.username + ' ')
if (media.caption):
log.write(media.caption.text.encode('utf8') + '---')
if (media.location):
log.write(media.location.name + ' ')
if (media.images):
log.write(media.images['standard_resolution'].url)
elif (media.videos):
log.write(media.videos['standard_resolution'].url)
import matplotlib.patches as mpatches
import mpld3
import pandas as pd
# Sets how many post to get
post_count = 40
# Creates a threshold for neutral post
neutral_min = 0.04
neutral_max = 0.215
min_subjectivity = 0.3
# Sets hashtag to be analyze (do no include the hashtag symbol)
hash_tag = 'cats'
# Set up Instagram API
client_id = '' # Replace with your key
client_secret = '' # Replace with your key
api = InstagramAPI(client_id=client_id, client_secret=client_secret)
def get_ids():
# Get all ids for all post
ids, next = api.tag_recent_media(tag_name=hash_tag, count=post_count)
temp, max_tag = next.split('max_tag_id=')
max_tag = str(max_tag)
while next and len(ids) < post_count:
more_ids, next = api.tag_recent_media(tag_name=hash_tag, count=max_tag)
temp, max_tag = next.split('max_tag_id=')
max_tag = str(max_tag)
for id in more_ids:
if len(ids) < post_count:
ids.append(id)
from __future__ import print_function
from __future__ import division
from instagram import client, subscriptions, InstagramAPI
import sys
from datetime import date, timedelta
import json
import time
import datetime
import shutil
import operator
from pylab import *
#access_token='1529897738.f4dfaeb.53403a45baed421ca216921b2f136c97'
#access_token='1529897738.2d6fe64.87556684de0d4ce1aa6afbf423a8cada'
access_token = '1546646729.2d6fe64.91d6953b286d467ea889016903648d96'
api = InstagramAPI(access_token=access_token)
print_all_users = 0
def is_empty(any_structure):
if any_structure:
#print('Structure is not empty.')
return False
else:
#print('Structure is empty.')
return True
#open source and results files
print("*** Remaining API Calls = %s/%s" %
(api.x_ratelimit_remaining, api.x_ratelimit))
def mlist(tag):
app.logger.debug("tag=" + tag)
api = InstagramAPI(client_id=CLIENT_ID)
items, next = api.tag_recent_media(count=12, tag_name=tag)
return render_template("_mitem.html", items=items)
bridge.twitter_last_id = new_tweets[0].id
bridge.updated = datetime.now()
new_tweets.reverse()
#
# Instagram
#
new_instas = []
if bridge.instagram_access_code:
l.debug(f"-- INSTAGRAM: {bridge.instagram_handle} --")
api = InstagramAPI(access_token=bridge.instagram_access_code, client_secret=c.INSTAGRAM_SECRET)
try:
recent_media, _ = api.user_recent_media(user_id=bridge.instagram_account_id)
except Exception as e:
l.error(e)
continue
for media in recent_media:
ts = datetime_to_timestamp(media.created_time)
if ts > bridge.instagram_last_id:
new_instas.append(media)
if c.SEND and len(new_instas) != 0: