def crawl_all_feeders():
api = InstagramAPI(access_token=access_token)
try:
#recent_media, next_ = api.user_recent_media(user_id="mmoorr", count=10)
media_feed, next_ = api.user_media_feed(count=20)
except InstagramAPIError as ie:
print("Instagram API error" + str(ie))
return
except Exception as e:
print("General exception" + str(e))
return
crawled={}
for media in media_feed:
if media.user.id in crawled: continue
crawled[media.user.id] = True
try:
recent_media, next_ = api.user_recent_media(user_id=media.user.id, count=10)
user_info = api.user(user_id=media.user.id)
except InstagramAPIError as ie:
print("Instagram API error" + str(ie))
return
except Exception as e:
print("General exception" + str(e))
return
print ("Got %d items for user %s"%(len(recent_media), media.user))
print ("This is %s, ID %s, bio %s, followed by %s"%(user_info.full_name,
user_info.id,
user_info.bio,
user_info.counts['followed_by']))
print ("++")
def handle(self, username, *args, **options):
user = AggieUser.objects.get(username=username)
account = BasicAccount.objects.get(user=user, type=BasicAccount.INSTAGRAM)
api = InstagramAPI(access_token=account.oauth_token, client_secret=settings.INSTAGRAM_SECRET)
feed, next_ = api.user_media_feed()
follows, _ = api.user_follows(user.accounts.filter(type=BasicAccount.INSTAGRAM).values_list('account_id', flat=True)[0])
while next_:
for item in feed:
if item.user.username in AggieUser.get_handles(user.get_friends()):
print item.caption, item.user, dir(item)
def get_user_media_feed():
api = InstagramAPI(access_token=session['access_token'])
recent_media, next = api.user_media_feed()
templateData = {
'size': request.args.get('size', 'thumb'),
'media': recent_media
}
return render_template('media.html', **templateData)
def User_Media_Feed(page=1):
u = InstagramAPI(access_token=session['access_token'],
client_secret=secrets['client_secret'])
media_feed, next_ = u.user_media_feed(count=20)
for i in range(1, page):
media_feed, next_ = u.user_media_feed(count=20, with_next_url=next_)
photos_thumbnail = []
photos_standard = []
title = "User Media Feed-Page " + str(page)
prev_page = False
next_page = False
if next_:
prev_page = True
if page != 1:
next_page = True
for media in media_feed:
photos_thumbnail.append("{}".format(media.images['thumbnail'].url))
photos_standard.append("{}".format(media.images['standard_resolution']
.url))
return render_template("recent.html", thumb=photos_thumbnail,
photos=photos_standard, prev=prev_page,
next=next_page, page=page, title=title)
def crawl_own():
api = InstagramAPI(access_token=access_token)
try:
#recent_media, next_ = api.user_recent_media(user_id="mmoorr", count=10)
media_feed, next_ = api.user_media_feed(count=20)
except InstagramAPIError as ie:
print("Instagram API error" + str(ie))
return
except Exception as e:
print("General exception" + str(e))
return
for media in media_feed:
print media.user
if media.caption:
print media.caption.text
print "++"
def home(request):
code = str(request.GET.get('code'))
oauth = OAuth2API(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, redirect_uri=REDIRECT_URI)
access_token, user_info = oauth.exchange_code_for_access_token(code)
# access_token, user_info = ('1327109423.a9fd754.8a4991734ff942ac9af1065eca26b96e', {'bio': u'', 'full_name': 'Bharadwaj Srigiriraju', 'id': '1327109423', 'website': u'', 'profile_picture': 'http://images.ak.instagram.com/profiles/anonymousUser.jpg', 'username': '******'})
request.session['access_token'] = access_token
api = InstagramAPI(access_token=access_token)
user_id = user_info['id']
follower_list, page_no = api.user_followed_by(user_id)
recent_timings = []
feed = api.user_media_feed()
media_feed = feed[0]
for media in media_feed:
recent_timings.append(media.created_time)
hours = []
days = {}
for datetime_obj in recent_timings:
hours.append(datetime_obj.hour)
day = datetime_obj.today().weekday()
if day not in days:
days[day] = 0
else:
days[day] += 1
hours_count = dict(Counter(hours))
sorted_hours = sorted(hours_count.items(), key=operator.itemgetter(1))
days_count = dict(Counter(days))
sorted_days = sorted(days_count.items(), key=operator.itemgetter(1))
res = []
day_name = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
day_number = int(sorted_days[len(sorted_days)-1][0])
for i in xrange(3):
astring = "The " + str(i+1) + " best time for you is: " + str(int(sorted_hours[len(sorted_hours)-i-1][0])-1) + ":30"
res.append(astring)
res.append("<br> The best day for you is: " + str(day_name[day_number]))
# for follower in follower_list:
# follower_id = follower.id
# recent_timings.append(api.user_recent_media(follower_id))
return HttpResponse('<br>'.join(res))
def get_media_feed(environ, format): query_string = environ['QUERY_STRING'] if query_string is not '': query_params = parse_params_from_query_string(query_string) access_token = query_params[0][1] authed_api = InstagramAPI(access_token=access_token) media_feed = authed_api.user_media_feed() media_feed = media_feed[0] [str(i) for i in media_feed] if format == 'json': return json.dumps(map(str, media_feed)) elif format == 'raw': return (media_feed, access_token) else: return 'Error: missing access token'
class instagramService:
def __init__(self, config):
self.config = config
self.api = InstagramAPI(access_token=config['access_token'])
self.version = 0
self.batch = []
self.batch_users = []
self.feed_count = 0
self.feed_count_total = 0
self.instagram_username = config['instagram_username']
self.instagram_user_id = config['instagram_user_id']
def stop_and_exit_service(self):
logging.debug('instagram Service - HARD QUIT - instagram SERVICE')
sys.exit()
def run_main_services(self):
main_services_d = Deferred()
try:
print "running instagram main services"
def find_followers_cb(res):
def find_friends_cb(res):
def get_authen_user_feed_cb(res):
def get_popular_media_cb(res):
main_services_d.callback(True)
self.get_popular_media().addCallbacks(
get_popular_media_cb, lambda failure: logging.
error("Update Error {0}".format(failure)))
self.get_authenticated_user_feed().addCallbacks(
get_authen_user_feed_cb, lambda failure: logging.error(
"Update Error {0}".format(failure)))
self.find_friends(
self.config['instagram_user_id']).addCallbacks(
find_friends_cb, lambda failure: logging.error(
"Update Error{0}".format(failure)))
self.find_followers(self.config['instagram_user_id']).addCallbacks(
find_followers_cb, lambda failure: logging.error(
"Update Error{0}".format(failure)))
#self.subscribe_to_objects_by_tag(self.config['instagram_search_words'])
except:
logging.debug(
'Service Instagram - Could not run main service due to error: {0}'
.format(sys.exc_info()))
return main_services_d
def get_indx(self):
return_d = Deferred()
def authed_cb():
logging.debug("in service_tweets - Authed Callback")
logging.debug(
"in service_tweets - get_indx authclient Auth status: {0}".
format(authclient.is_authed))
def token_cb(token):
self.indx_con = IndxClient(self.config['address'],
self.config['box'],
appid,
token=token,
client=authclient.client)
return_d.callback(True)
authclient.get_token(self.config['box']).addCallbacks(
token_cb, return_d.errback)
def authed_cb_fail(re):
logging.debug(
"in service tweets - get_indx/authed_cb failed for reason {0}".
format(re))
return_d.errback
logging.debug("in service_instagram - get_indx")
authclient = IndxClientAuth(self.config['address'], appid)
authclient.auth_plain(self.config['user'],
self.config['password']).addCallbacks(
lambda response: authed_cb(), authed_cb_fail)
return return_d
def get_authenticated_user_feed(self):
auth_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = ""
#let's see if the object has some nice things in it.
try:
config_returned = results['data']['service_instagram_config']
friends_number = int(
config_returned['friends_list_size'][0]['@value'])
followers_number = int(
config_returned['followers_list_size'][0]['@value'])
since_id = int(config_returned['since_id'][0]['@value'])
logging.info('Found the instagram Config Object.')
except:
#print sys.exc_info()
pass
#print "Getting Auth User's feed"
user_feed = self.api.user_media_feed()[0]
try:
latest_id = user_feed[0].id
except:
latest_id = "Null"
##find the highest id...
if (latest_id != since_id):
logging.info("Found some new media, will insert it to INDX")
since_id = latest_id
objects_to_insert = []
current_timestamp = str(
time.time()).split(".")[0] #str(datetime.now())
timestamp = str(datetime.now().isoformat('T')).split(".")[0]
current_timestamp = str(datetime.now())
#the user responsible for this
#now create some nice user objects...
for media in user_feed:
media_user_id = media.user.id
media_username = media.user.username
uniq_id = "instagram_media_" + media.id
user_feed_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "post",
"instagram_user_id_indx": "instagram_user_me",
"instagram_user_id": media_user_id,
"instagram_username": media_username,
"media_id": media.id,
"media_caption": media.caption,
"media_url": media.get_standard_resolution_url(),
"media_like_count": media.like_count
}
#need to add INDX objects for tags and locations and the indx user of this
#create location if available
try:
location = media.location
uniq_id = "instagram_location_" + location.id
location_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "location",
"instagram_location_id": location.id,
"location_name": location.name,
"latitude": location.point.latitude,
"longitude": location.point.longitude
}
#now add this location to the user_feed_obj
user_feed_obj['media_location_id'] = location_obj
#thhen add it to a list of ojects to insert.
objects_to_insert.append(location_obj)
except:
pass
try:
tag_ids = []
for tag in media.tags:
uniq_id = "instagram_tag_" + tag.name
tag_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "tag",
"instagram_tag_name": tag.name
}
tag_ids.append(uniq_id)
objects_to_insert.append(tag_obj)
#now add this location to the user_feed_obj
user_feed_obj['tags'] = tag_ids
except:
pass
objects_to_insert.append(user_feed_obj)
#now create the instagram_user_me object
uniq_id = "instagram_user_me"
instagram_me_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "user",
"instagram_user_id": media_user_id,
"instagram_username": media_username
}
objects_to_insert.append(instagram_me_obj)
#and create the instagram config
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id
}
objects_to_insert.append(instagram_config_obj)
def update_cb(re):
logging.debug(
"network harvest async worked {0}".format(re))
auth_d.callback(True)
def update_cb_fail(re):
logging.error(
"network harvest async failed {0}".format(re))
auth_d.errback
self.insert_object_to_indx(objects_to_insert).addCallbacks(
update_cb, update_cb_fail)
else:
logging.info(
"already have the latest version of your instagram timeline"
)
auth_d.callback(True)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info(
"Searching for instagram_config to check if Popular feed already harvested... "
)
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return auth_d
# for feed in user_feed:
# print feed
def get_searched_media(self, search_terms):
print "getting searched media for terms: " + str(search_terms)
returned_results, page_num = self.api.tag_search(search_terms, 20)
return returned_results
# for result in returned_results:
# print result
def get_popular_media(self):
pop_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = ""
#let's see if the object has some nice things in it.
try:
config_returned = results['data']['service_instagram_config']
friends_number = int(
config_returned['friends_list_size'][0]['@value'])
followers_number = int(
config_returned['followers_list_size'][0]['@value'])
since_id = int(config_returned['since_id'][0]['@value'])
logging.info('Found the instagram Config Object.')
except:
#print sys.exc_info()
pass
#if(since_id > 0):
logging.info("getting popular media")
objects_to_insert = []
current_timestamp = str(
time.time()).split(".")[0] #str(datetime.now())
timestamp = str(datetime.now().isoformat('T')).split(".")[0]
current_timestamp = str(datetime.now())
popular_media = self.api.media_popular(count=20)
for media in popular_media:
media_user_id = media.user.id
media_username = media.user.username
#now create the instagram_user object
uniq_user_id = "instagram_user_" + media.user.id
instagram_media_obj = {
"@id": uniq_user_id,
"app_object": appid,
"timestamp": timestamp,
"type": "user",
"instagram_user_id": media_user_id,
"instagram_username": media_username
}
objects_to_insert.append(instagram_media_obj)
uniq_id = "instagram_media_" + media.id
media_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "post",
"instagram_user_id_indx": uniq_user_id,
"instagram_user_id": media_user_id,
"instagram_username": media_username,
"media_id": media.id,
"media_caption": media.caption,
"media_url": media.get_standard_resolution_url(),
"media_like_count": media.like_count
}
#need to add INDX objects for tags and locations and the indx user of this
#create location if available
try:
location = media.location
uniq_id = "instagram_location_" + location.id
location_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "location",
"instagram_location_id": location.id,
"location_name": location.name,
"latitude": location.point.latitude,
"longitude": location.point.longitude
}
#now add this location to the user_feed_obj
media_obj['media_location_id'] = location_obj
#thhen add it to a list of ojects to insert.
objects_to_insert.append(location_obj)
except:
pass
try:
tag_ids = []
for tag in media.tags:
uniq_id = "instagram_tag_" + tag.name
tag_obj = {
"@id": uniq_id,
"app_object": appid,
"type": "tag",
"timestamp": timestamp,
"instagram_tag_name": tag.name
}
tag_ids.append(uniq_id)
objects_to_insert.append(tag_obj)
#now add this location to the user_feed_obj
media_obj['tags'] = tag_ids
except:
pass
objects_to_insert.append(media_obj)
def update_cb(re):
logging.debug("network harvest async worked {0}".format(re))
pop_d.callback(True)
def update_cb_fail(re):
logging.error("network harvest async failed {0}".format(re))
pop_d.errback
#and create the instagram config
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id
}
objects_to_insert.append(instagram_config_obj)
self.insert_object_to_indx(objects_to_insert).addCallbacks(
update_cb, update_cb_fail)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info(
"Searching for instagram_config to check if Popular feed already harvested... "
)
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return pop_d
def find_user(self, username):
data = self.api.user_search(username, count=20)
print data
def find_followers(self, userid):
#first do a lookup and see if the latest set if followers has allready been found
follower_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = 0
#let's see if the object has some nice things in it.
try:
config_returned = results['data']['service_instagram_config']
friends_number = int(
config_returned['friends_list_size'][0]['@value'])
followers_number = int(
config_returned['followers_list_size'][0]['@value'])
since_id = int(config_returned['since_id'][0]['@value'])
logging.info('Found the instagram Config Object.')
except:
#print sys.exc_info()
pass
followed_by = self.api.user_followed_by(userid)[0]
#print "followed_by length: "+str(len(followed_by))
#print str(followed_by)
#see if the number is different, if it is, then update.. could be nicer than this, but for now, it will work (ish)
if (len(followed_by) != followers_number) or (followers_number
== 0):
followers_number = len(followed_by)
objects_to_insert = []
current_timestamp = str(
time.time()).split(".")[0] #str(datetime.now())
timestamp = str(datetime.now().isoformat('T')).split(".")[0]
uniq_id = "instagram_follower_network_for_user_me" #+self.instagram_username
followed_by_obj = {
"@id": uniq_id,
"app_object": appid,
"instagram_username": self.instagram_username,
"instagram_user_id": self.instagram_user_id,
"timestamp": timestamp,
"followed_by_count": len(followed_by)
}
followers_ids = []
for follower in followed_by:
#print follower.username
uniq_id = "instagram_user_" + str(follower.username)
follower_obj = {
"@id": uniq_id,
"app_object": appid,
"type": "user",
"instagram_username": str(follower.username),
"timestamp": timestamp
}
objects_to_insert.append(follower_obj)
#we can add this to the followed_by_obj later
followers_ids.append(uniq_id)
#link the followers for me
followed_by_obj['follower_ids'] = followers_ids
# print followed_by_objs
#for friend in friends_list:
#print friend
#now append the results
def update_cb(re):
logging.debug(
"network harvest async worked {0}".format(re))
follower_d.callback(True)
def update_cb_fail(re):
logging.error(
"network harvest async failed {0}".format(re))
follower_d.errback
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id
}
objects_to_insert.append(followed_by_obj)
#objects_to_insert.append(followers)
objects_to_insert.append(instagram_config_obj)
self.insert_object_to_indx(objects_to_insert).addCallbacks(
update_cb, update_cb_fail)
else:
follower_d.callback(True)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info(
"Searching for instagram_config to check if network already harvested... "
)
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return follower_d
# print followed_by
def find_friends(self, userid):
friends_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = 0
#let's see if the object has some nice things in it.
try:
config_returned = results['data']['service_instagram_config']
friends_number = int(
config_returned['friends_list_size'][0]['@value'])
followers_number = int(
config_returned['followers_list_size'][0]['@value'])
since_id = int(config_returned['since_id'][0]['@value'])
logging.info('Found the instagram Config Object.')
except:
#print sys.exc_info()
pass
friends_by_list = self.api.user_follows(userid)[0]
if (len(friends_by_list) != friends_number) or (friends_number
== 0):
friends_number = len(friends_by_list)
objects_to_insert = []
current_timestamp = str(
time.time()).split(".")[0] #str(datetime.now())
timestamp = str(datetime.now().isoformat('T')).split(".")[0]
uniq_id = "instagram_friends_network_for_user_me" #+self.instagram_username
friends_by_obj = {
"@id": uniq_id,
"app_object": appid,
"instagram_username": self.instagram_username,
"instagram_user_id": self.instagram_user_id,
"timestamp": timestamp,
"followed_by_count": len(friends_by_list)
}
friends_ids = []
for friend in friends_by_list:
#print follower.username
uniq_id = "instagram_user_" + str(friend.username)
friend_obj = {
"@id": uniq_id,
"app_object": appid,
"type": "user",
"instagram_username": str(friend.username),
"timestamp": timestamp
}
objects_to_insert.append(friend_obj)
#we can add this to the followed_by_obj later
friends_ids.append(uniq_id)
friends_by_obj['friends_ids'] = friends_ids
# print friends_by_objs
#for friend in friends_list:
#print friend
#now append the results
def update_cb(re):
logging.debug(
"network harvest async worked {0}".format(re))
friends_d.callback(True)
def update_cb_fail(re):
logging.error(
"network harvest async failed {0}".format(re))
friends_d.errback
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id
}
objects_to_insert.append(friends_by_obj)
#objects_to_insert.append(followers)
objects_to_insert.append(instagram_config_obj)
self.insert_object_to_indx(objects_to_insert).addCallbacks(
update_cb, update_cb_fail)
else:
friends_d.callback(True)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info(
"Searching for instagram_config to check if network already harvested... "
)
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return friends_d
# print followed_by
def subscribe_to_objects_by_tag(self, search_terms):
def process_tag_update(update):
print update
reactor = subscriptions.SubscriptionsReactor()
reactor.register_callback(subscriptions.SubscriptionType.TAG,
process_tag_update)
self.api.create_subscription(object='tag',
object_id=search_terms,
aspect='media',
callback_url='http://*****:*****@version']
logging.debug(
"Succesfully Updated INDX with Objects in update_cb, new diff version of {0}"
.format(self.version))
#logging.debug("Inserted Object into INDX: ".format(resp))
update_d.callback(True)
#return update_d
#time.sleep(2)
def exception_cb(e, service=self, obj=obj):
logging.debug(
"Exception Inserting into INDX, probably wrong version given")
if isinstance(
e.value, urllib2.HTTPError
): # handle a version incorrect error, and update the version
if e.value.code == 409: # 409 Obsolete
response = e.value.read()
json_response = json.loads(response)
service.version = json_response['@version']
logging.debug(
'INDX insert error in Instagram Service Object: ' +
str(response))
try:
service.indx_con.update(service.version,
obj).addCallbacks(
update_cb, exception_cb)
#logging.debug('Twitter Service - Successfully added Objects into Box')
except:
logging.error(
'Instagram Service, error on insert {0}'.format(
response))
update_d.errback(e.value)
else:
logging.error('Instagram Service Unknow error: {0}'.format(
e.value.read()))
update_d.errback(e.value)
else:
logging.error("Error updating INDX: {0}".format(e.value))
update_d.errback(e.value)
logging.debug(
"in Instagram - Trying to insert into indx...Current diff version: {0} and objects (len) given {1}"
.format(self.version, len(obj)))
self.indx_con.update(self.version,
obj).addCallbacks(update_cb, exception_cb)
return update_d
class Instagram:
def __init__(self):
self.api = InstagramAPI(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, redirect_uri=REDIRECT_URI)
def set_access_token(self, access_token):
self.api = InstagramAPI(access_token=access_token)
def media_popular(self, **params):
popular = memcache.get("popular_feed")
if not popular:
popular = self.api.media_popular(count=params["count"], max_id=params["max_id"])
memcache.add("popular_feed", popular, 300)
return popular
def user_media_feed(self, **params):
user_id = params["user_id"]
max_id = params["max_id"]
count = params["count"]
feed = memcache.get("user_media_feed_%s_%s" % (user_id, max_id))
if not feed:
feed = self.api.user_media_feed(count=count, max_id=max_id)
memcache.add("user_media_feed_%s_%s" % (user_id, max_id), feed, 300)
return feed
def user_liked_feed(self, **params):
user_id = params["user_id"]
max_id = params["max_id"]
count = params["count"]
feed = memcache.get("user_liked_feed_%s_%s" % (user_id, max_id))
if not feed:
feed = self.api.user_liked_feed(count=count, max_like_id=max_id)
memcache.add("user_liked_feed_%s_%s" % (user_id, max_id), feed, 300)
return feed
def user(self, user_id):
user = memcache.get("user_%s" % (user_id))
if not user:
user = self.api.user(user_id)
user["full_name"] = escape(user["full_name"].encode("utf-8"))
user["full_name"] = self._convert_emoji(user["full_name"])
memcache.add("user_%s" % (user_id), user, 300)
return user
def media(self, media_id):
media = memcache.get("media_%s" % media_id)
if not media:
media = self.api.media(media_id)
media.user["full_name"] = escape(media.user["full_name"].encode("utf-8"))
media.user["full_name"] = self._convert_emoji(media.user["full_name"])
if media.caption:
media.caption["text_original"] = media.caption["text"]
media.caption["text"] = escape(media.caption["text"].encode("utf-8"))
media.caption["text"] = self._convert_emoji(media.caption["text"])
media.caption["text"] = self._convert_tag_to_link(media.caption["text"])
memcache.add("media_%s" % media_id, media, 300)
return media
def media_comments(self, media_id):
comments = memcache.get("media_comments_%s" % (media_id))
if not comments:
converter = emoji.factory("softbank", "utf-8")
converter.prefix = '<span class="emoji emoji_'
converter.suffix = '"></span>'
comments = self.api.media_comments(media_id)
for comment in comments:
comment["text"] = escape(comment["text"].encode("utf-8"))
comment["text"] = self._convert_emoji(comment["text"])
comment["text"] = self._convert_tag_to_link(comment["text"])
memcache.add("media_comments_%s" % (media_id), comments, 300)
return comments
def media_likes(self, media_id):
likes = memcache.get("media_likes_%s" % (media_id))
if not likes:
likes = self.api.media_likes(media_id)
memcache.add("media_likes_%s" % (media_id), likes, 300)
return likes
def user_recent_media(self, **params):
user_id = params["user_id"]
max_id = params["max_id"]
feed = memcache.get("user_recent_media_%s_%s" % (user_id, max_id))
if not feed:
feed = self.api.user_recent_media(user_id=user_id, max_id=max_id)
memcache.add("user_recent_media_%s_%s" % (user_id, max_id), feed, 300)
return feed
def user_follows(self, **params):
user_id = params["user_id"]
count = params["count"]
cursor = params["cursor"]
follows = memcache.get("user_follows_%s_%s_%s" % (user_id, count, cursor))
if not follows:
follows = self.api.user_follows(user_id=user_id, count=count, cursor=cursor)
for user in follows[0]:
user["full_name"] = escape(user["full_name"].encode("utf-8"))
user["full_name"] = self._convert_emoji(user["full_name"])
memcache.add("user_follows_%s_%s_%s" % (user_id, count, cursor), follows, 300)
return follows
def user_followed_by(self, **params):
user_id = params["user_id"]
count = params["count"]
cursor = params["cursor"]
follows = memcache.get("user_followed_by_%s_%s_%s" % (user_id, count, cursor))
if not follows:
follows = self.api.user_followed_by(user_id=user_id, count=count, cursor=cursor)
for user in follows[0]:
user["full_name"] = escape(user["full_name"].encode("utf-8"))
user["full_name"] = self._convert_emoji(user["full_name"])
memcache.add("user_followed_by_%s_%s_%s" % (user_id, count, cursor), follows, 300)
return follows
def like_media(self, **params):
user_id = params["user_id"]
media_id = params["media_id"]
max_id = params["max_id"]
self.api.like_media(media_id)
memcache.add("user_has_liked_%s_%s" % (user_id, media_id), True, 300)
memcache.delete("media_likes_%s" % (media_id))
def unlike_media(self, **params):
user_id = params["user_id"]
media_id = params["media_id"]
max_id = params["max_id"]
self.api.unlike_media(media_id)
memcache.delete("user_has_liked_%s_%s" % (user_id, media_id))
memcache.delete("media_likes_%s" % (media_id))
def create_media_comment(self, **params):
media_id = params["media_id"]
text = params["text"]
self.api.create_media_comment(media_id=media_id, text=text)
memcache.delete("media_%s" % media_id)
memcache.delete("media_comments_%s" % media_id)
def user_find_by_username(self, username):
user = memcache.get("user_find_by_username_%s" % (username))
if not user:
users = self.api.user_search(q=username, count=None)
for u in users:
if username == u["username"]:
user = u
memcache.add("user_find_by_username_%s" % (username), user)
return user
def tag_recent_media(self, **params):
tag_name = params["tag_name"]
count = params["count"]
max_id = params["max_id"]
feed = memcache.get("tag_recent_media_%s_%s" % (tag_name, max_id))
if not feed:
feed = self.api.tag_recent_media(tag_name=tag_name, count=count, max_id=max_id)
memcache.add("tag_recent_media_%s_%s" % (tag_name, max_id), feed, 300)
return feed
def get_authorize_login_url(self, **params):
uri = memcache.get("authorize_login_uri")
if not uri:
uri = self.api.get_authorize_login_url(scope=params["scope"])
memcache.add("authorize_login_uri", uri, 300)
return uri
def _convert_emoji(self, text):
converter = emoji.factory("softbank", "utf-8")
converter.prefix = '<span class="emoji emoji_'
converter.suffix = '"></span>'
text = converter.convert(text)
return text
def _convert_tag_to_link(self, text):
text = re.sub(r"#([a-zA-Z0-9\-]+)", '<a href="/tag/\g<1>">#\g<1></a>', text)
return text
def relationship(self, **params):
owner_id = params["owner_id"]
my_id = params["my_id"]
relationship = memcache.get("relationship_%s_%s" % (my_id, owner_id))
if not relationship:
relationship = self.api.relationship(owner_id)
memcache.add("relationship_%s_%s" % (my_id, owner_id), relationship, 300)
return relationship
def follow_user(self, **params):
owner_id = params["owner_id"]
my_id = params["my_id"]
relationship = self.api.follow_user(user_id=owner_id)
memcache.delete("relationship_%s_%s" % (my_id, owner_id))
return relationship
def unfollow_user(self, **params):
owner_id = params["owner_id"]
my_id = params["my_id"]
relationship = self.api.unfollow_user(user_id=owner_id)
memcache.delete("relationship_%s_%s" % (my_id, owner_id))
return relationship
client_id = '721cc35baafa4abf9c22a6cd58ac9253'
client_secret = 'bdac16788ab6432ca614a3d8164ff94f'
access_token = '1906277004.721cc35.83458773c49b4fedb4fa3df48a2de95b'
client_ip = '192.168.44.138'
#client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri
api = InstagramAPI(client_id=client_id, client_secret=client_secret, client_ips= client_ip,access_token= access_token)
#from instagram.client import InstagramAPI
#api = InstagramAPI(client_id='YOUR_CLIENT_ID', client_secret='YOUR_CLIENT_SECRET')
#popular_media = api.media_popular(count=3)
#for media in popular_media:
#print media.images['standard_resolution'].url
#stringmaybe = api.user('goalsstretch')
mymedia = api.user_media_feed()
print mymedia, len(mymedia[0])
f1=open('robswebsite.html', 'w')
print >>f1, '<html>\n<head>\n\n<title>Rob\'s Website!!</title>\n</head>\n\n'
print >>f1, '<body>\n<h1>This is my website!!!!</h1>\n'
for media_obj in mymedia[0]:
myurl = media_obj.get_standard_resolution_url()
print myurl, type(myurl)
print >>f1, '<div><img src="%s" alt="Me stretching"></div>\n' % myurl
print >>f1, '</body>'
from instagram.client import InstagramAPI CLIENT_ID = "" client_secret = "" api = InstagramAPI(CLIENT_ID, client_secret) user_id = "jerrinjoe" api.user(user_id) print(api.user_media_feed())
class InstagramFeed(object):
_logger = inject.attr(Logger)
_settingsController = inject.attr(SettingsController)
_databaseController = inject.attr(DatabaseController)
_tableName = 'InstagramFeed'
def __init__(self):
self._logger.debug('InstagramFeed::__init__')
self._initApi()
self._initTable()
def getNext(self):
self._logger.debug('InstagramFeed::getNext')
if not self._hasNext():
self._fetch()
return self._getNextMediaFromDatabase()
def like(self, id):
self._logger.debug('InstagramFeed::like')
self._api.like_media(id)
def _initApi(self):
self._logger.debug('InstagramFeed::_initApi')
clientId = self._settingsController.get('CLIENT_ID')
clientSecret = self._settingsController.get('SECRET_ID')
accessToken = self._settingsController.get('ACCESS_TOKEN')
self._api = InstagramAPI(client_id=clientId, client_secret=clientSecret, access_token=accessToken)
def _initTable(self):
self._logger.debug('InstagramFeed::_initTable')
sql = 'create table if not exists {0} (id text, url text)'.format(self._tableName)
self._databaseController.executeCommand(sql)
def _hasNext(self):
self._logger.debug('InstagramFeed::_hasNext')
sql = 'select count(*) from {0}'.format(self._tableName)
return self._databaseController.executeQuery(sql)[0][0] > 0
def _getNextMediaFromDatabase(self):
self._logger.debug('InstagramFeed::_getNextMediaFromDatabase')
sql = "select id, url from {0} order by id desc limit 0, 1".format(self._tableName)
result = self._databaseController.executeQuery(sql)
media = Media(result[0][0], result[0][1])
media.delete()
return media
def _fetch(self):
self._logger.debug('InstagramFeed::_fetch')
currentFeed = self._settingsController.get('CURRENT_FEED')
medias = None
if currentFeed == 'popular':
medias = self._fetchPopularFeed()
elif currentFeed == 'personal':
medias = self._fetchPersonalFeed()
if medias:
self._saveMedias(medias)
def _fetchPopularFeed(self):
self._logger.debug('InstagramFeed::_fetchPopularFeed')
return self._api.media_popular(count=40)
def _fetchPersonalFeed(self):
self._logger.debug('InstagramFeed::_fetchPersonalFeed')
return self._api.user_media_feed(count=40)[0]
def _saveMedias(self, medias):
self._logger.debug('InstagramFeed::_saveMedias')
for media in medias:
Media(media.id, media.images['standard_resolution'].url).create()
def InstagramProcces(self):
self.aceptar.setCursor(QCursor(Qt.ForbiddenCursor))
self.update_progressbar(10)
access_token = self.lnToken.text()
client_secret = self.lnAcces.text()
user_id = self.lnId.text()
if not access_token or not client_secret:
QMessageBox.information(
self, "Empty values",
"Complete mandatory items <access_token> and <client_secret>",
QMessageBox.AcceptRole)
return
try:
api = InstagramAPI(access_token=access_token,
client_secret=client_secret)
#Search recent media with Tag
if self.TypeSearch == "hashtags":
count = self.sp_count.value()
tag = self.ln_tags.text()
if tag == "":
QMessageBox.information(self, "Empty values",
"Tag value is empty",
QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
tag_search, next_tag = api.tag_search(tag)
tag_recent_media, next = api.tag_recent_media(
count, tag_name=tag_search[0].name)
if len(tag_recent_media) == 0: return self.Checklength()
categorized, layer = self.CreateShape()
for tag_media in tag_recent_media:
self.AddFeatures(tag_media, layer, categorized)
#Search recent media with Location
elif self.TypeSearch == "coords":
lat = self.ln_lat.text()
lng = self.ln_lng.text()
distance = self.sp_distance.value()
location_search = api.media_search(lat=str(lat),
lng=str(lng),
distance=int(distance))
if len(location_search) == 0: return self.Checklength()
categorized, layer = self.CreateShape()
for location in location_search:
self.AddFeatures(location, layer, categorized)
#Search recent media with user
elif self.TypeSearch == "user":
if self.lnId.text() == "":
QMessageBox.information(self, "Empty values",
"User name value is empty",
QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
user_name = self.lnId.text()
user_search = api.user_search(user_name)
if len(user_search) == 0: return self.Checklength()
layer = self.CreateShapeMin()
for user in user_search:
self.AddFeaturesMin(user, layer)
#Search user recent
elif self.TypeSearch == "user_recent":
recent_media, next = api.user_recent_media()
if len(recent_media) == 0: return self.Checklength()
categorized, layer = self.CreateShape()
for media in recent_media:
self.AddFeatures(media, layer, categorized)
#Search User Media Feed
elif self.TypeSearch == "user_media":
media_feed, next = api.user_media_feed()
if len(media_feed) == 0: return self.Checklength()
categorized, layer = self.CreateShape()
for media in media_feed:
self.AddFeatures(media, layer, categorized)
#Search User follow
elif self.TypeSearch == "user_follow":
if self.lnId.text() == "":
QMessageBox.information(self, "Empty values",
"User ID value is empty",
QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
user_follows, next = api.user_follows(user_id)
if len(user_follows) == 0: return self.Checklength()
layer = self.CreateShapeMin()
for user in user_follows:
self.AddFeaturesMin(user, layer)
#Search Location recent
elif self.TypeSearch == "location_recent":
if self.ln_loc_id.text() == "":
QMessageBox.information(self, "Empty values",
"Location ID value is empty",
QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
location_id = int(self.ln_loc_id.text())
recent_media, next = api.location_recent_media(
location_id=location_id)
if len(recent_media) == 0: return self.Checklength()
categorized, layer = self.CreateShape()
for media in recent_media:
self.AddFeatures(media, layer, categorized)
#Search recent popular
elif self.TypeSearch == "popular":
media_search = api.media_popular()
if len(media_search) == 0: return self.Checklength()
categorized, layer = self.CreateShape()
for media in media_search:
self.AddFeatures(media, layer, categorized)
#Save layer in output path
QgsVectorFileWriter.writeAsVectorFormat(
layer, self.settings.value("instagram2qgis/outpath"), "CP1250",
None, "ESRI Shapefile")
self.update_progressbar(100)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.reject()
except Exception as e:
self.iface.messageBar().pushMessage("Error: ",
"fail to load photos: " +
str(e),
level=QgsMessageBar.CRITICAL,
duration=20)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
return
followers, next_ = api.user_followed_by()
while next_:
more_followers, next_ = api.user_followed_by(with_next_url=next_)
followers.extend(more_followers)
# get followees
followees, next_ = api.user_follows()
while next_:
more_followees, next_ = api.user_follows(with_next_url=next_)
followees.extend(more_followees)
# intersect followers and followees
set([f.username for f in followers]) & set([f.username for f in followees])
# get user feed
media_feed, next_ = api.user_media_feed(count=20)
for media in media_feed:
# print user
print media.user
# print caption
if media.caption:
print media.caption.text
print "++"
# get followed people media and info
crawled={}
for media in media_feed:
if media.user.id in crawled:
continue
crawled[media.user.id] = True
# friend's recent media
class instagramService:
def __init__(self, config):
self.config = config
self.api = InstagramAPI(access_token=config["access_token"])
self.version = 0
self.batch = []
self.batch_users = []
self.feed_count = 0
self.feed_count_total = 0
self.instagram_username = config["instagram_username"]
self.instagram_user_id = config["instagram_user_id"]
def stop_and_exit_service(self):
logging.debug("instagram Service - HARD QUIT - instagram SERVICE")
sys.exit()
def run_main_services(self):
main_services_d = Deferred()
try:
print "running instagram main services"
def find_followers_cb(res):
def find_friends_cb(res):
def get_authen_user_feed_cb(res):
def get_popular_media_cb(res):
main_services_d.callback(True)
self.get_popular_media().addCallbacks(
get_popular_media_cb, lambda failure: logging.error("Update Error {0}".format(failure))
)
self.get_authenticated_user_feed().addCallbacks(
get_authen_user_feed_cb, lambda failure: logging.error("Update Error {0}".format(failure))
)
self.find_friends(self.config["instagram_user_id"]).addCallbacks(
find_friends_cb, lambda failure: logging.error("Update Error{0}".format(failure))
)
self.find_followers(self.config["instagram_user_id"]).addCallbacks(
find_followers_cb, lambda failure: logging.error("Update Error{0}".format(failure))
)
# self.subscribe_to_objects_by_tag(self.config['instagram_search_words'])
except:
logging.debug("Service Instagram - Could not run main service due to error: {0}".format(sys.exc_info()))
return main_services_d
def get_indx(self):
return_d = Deferred()
def authed_cb():
logging.debug("in service_tweets - Authed Callback")
logging.debug("in service_tweets - get_indx authclient Auth status: {0}".format(authclient.is_authed))
def token_cb(token):
self.indx_con = IndxClient(
self.config["address"], self.config["box"], appid, token=token, client=authclient.client
)
return_d.callback(True)
authclient.get_token(self.config["box"]).addCallbacks(token_cb, return_d.errback)
def authed_cb_fail(re):
logging.debug("in service tweets - get_indx/authed_cb failed for reason {0}".format(re))
return_d.errback
logging.debug("in service_instagram - get_indx")
authclient = IndxClientAuth(self.config["address"], appid)
authclient.auth_plain(self.config["user"], self.config["password"]).addCallbacks(
lambda response: authed_cb(), authed_cb_fail
)
return return_d
def get_authenticated_user_feed(self):
auth_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = ""
# let's see if the object has some nice things in it.
try:
config_returned = results["data"]["service_instagram_config"]
friends_number = int(config_returned["friends_list_size"][0]["@value"])
followers_number = int(config_returned["followers_list_size"][0]["@value"])
since_id = int(config_returned["since_id"][0]["@value"])
logging.info("Found the instagram Config Object.")
except:
# print sys.exc_info()
pass
# print "Getting Auth User's feed"
user_feed = self.api.user_media_feed()[0]
try:
latest_id = user_feed[0].id
except:
latest_id = "Null"
##find the highest id...
if latest_id != since_id:
logging.info("Found some new media, will insert it to INDX")
since_id = latest_id
objects_to_insert = []
current_timestamp = str(time.time()).split(".")[0] # str(datetime.now())
timestamp = str(datetime.now().isoformat("T")).split(".")[0]
current_timestamp = str(datetime.now())
# the user responsible for this
# now create some nice user objects...
for media in user_feed:
media_user_id = media.user.id
media_username = media.user.username
uniq_id = "instagram_media_" + media.id
user_feed_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "post",
"instagram_user_id_indx": "instagram_user_me",
"instagram_user_id": media_user_id,
"instagram_username": media_username,
"media_id": media.id,
"media_caption": media.caption,
"media_url": media.get_standard_resolution_url(),
"media_like_count": media.like_count,
}
# need to add INDX objects for tags and locations and the indx user of this
# create location if available
try:
location = media.location
uniq_id = "instagram_location_" + location.id
location_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "location",
"instagram_location_id": location.id,
"location_name": location.name,
"latitude": location.point.latitude,
"longitude": location.point.longitude,
}
# now add this location to the user_feed_obj
user_feed_obj["media_location_id"] = location_obj
# thhen add it to a list of ojects to insert.
objects_to_insert.append(location_obj)
except:
pass
try:
tag_ids = []
for tag in media.tags:
uniq_id = "instagram_tag_" + tag.name
tag_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "tag",
"instagram_tag_name": tag.name,
}
tag_ids.append(uniq_id)
objects_to_insert.append(tag_obj)
# now add this location to the user_feed_obj
user_feed_obj["tags"] = tag_ids
except:
pass
objects_to_insert.append(user_feed_obj)
# now create the instagram_user_me object
uniq_id = "instagram_user_me"
instagram_me_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "user",
"instagram_user_id": media_user_id,
"instagram_username": media_username,
}
objects_to_insert.append(instagram_me_obj)
# and create the instagram config
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id,
}
objects_to_insert.append(instagram_config_obj)
def update_cb(re):
logging.debug("network harvest async worked {0}".format(re))
auth_d.callback(True)
def update_cb_fail(re):
logging.error("network harvest async failed {0}".format(re))
auth_d.errback
self.insert_object_to_indx(objects_to_insert).addCallbacks(update_cb, update_cb_fail)
else:
logging.info("already have the latest version of your instagram timeline")
auth_d.callback(True)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info("Searching for instagram_config to check if Popular feed already harvested... ")
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return auth_d
# for feed in user_feed:
# print feed
def get_searched_media(self, search_terms):
print "getting searched media for terms: " + str(search_terms)
returned_results, page_num = self.api.tag_search(search_terms, 20)
return returned_results
# for result in returned_results:
# print result
def get_popular_media(self):
pop_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = ""
# let's see if the object has some nice things in it.
try:
config_returned = results["data"]["service_instagram_config"]
friends_number = int(config_returned["friends_list_size"][0]["@value"])
followers_number = int(config_returned["followers_list_size"][0]["@value"])
since_id = int(config_returned["since_id"][0]["@value"])
logging.info("Found the instagram Config Object.")
except:
# print sys.exc_info()
pass
# if(since_id > 0):
logging.info("getting popular media")
objects_to_insert = []
current_timestamp = str(time.time()).split(".")[0] # str(datetime.now())
timestamp = str(datetime.now().isoformat("T")).split(".")[0]
current_timestamp = str(datetime.now())
popular_media = self.api.media_popular(count=20)
for media in popular_media:
media_user_id = media.user.id
media_username = media.user.username
# now create the instagram_user object
uniq_user_id = "instagram_user_" + media.user.id
instagram_media_obj = {
"@id": uniq_user_id,
"app_object": appid,
"timestamp": timestamp,
"type": "user",
"instagram_user_id": media_user_id,
"instagram_username": media_username,
}
objects_to_insert.append(instagram_media_obj)
uniq_id = "instagram_media_" + media.id
media_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "post",
"instagram_user_id_indx": uniq_user_id,
"instagram_user_id": media_user_id,
"instagram_username": media_username,
"media_id": media.id,
"media_caption": media.caption,
"media_url": media.get_standard_resolution_url(),
"media_like_count": media.like_count,
}
# need to add INDX objects for tags and locations and the indx user of this
# create location if available
try:
location = media.location
uniq_id = "instagram_location_" + location.id
location_obj = {
"@id": uniq_id,
"app_object": appid,
"timestamp": timestamp,
"type": "location",
"instagram_location_id": location.id,
"location_name": location.name,
"latitude": location.point.latitude,
"longitude": location.point.longitude,
}
# now add this location to the user_feed_obj
media_obj["media_location_id"] = location_obj
# thhen add it to a list of ojects to insert.
objects_to_insert.append(location_obj)
except:
pass
try:
tag_ids = []
for tag in media.tags:
uniq_id = "instagram_tag_" + tag.name
tag_obj = {
"@id": uniq_id,
"app_object": appid,
"type": "tag",
"timestamp": timestamp,
"instagram_tag_name": tag.name,
}
tag_ids.append(uniq_id)
objects_to_insert.append(tag_obj)
# now add this location to the user_feed_obj
media_obj["tags"] = tag_ids
except:
pass
objects_to_insert.append(media_obj)
def update_cb(re):
logging.debug("network harvest async worked {0}".format(re))
pop_d.callback(True)
def update_cb_fail(re):
logging.error("network harvest async failed {0}".format(re))
pop_d.errback
# and create the instagram config
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id,
}
objects_to_insert.append(instagram_config_obj)
self.insert_object_to_indx(objects_to_insert).addCallbacks(update_cb, update_cb_fail)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info("Searching for instagram_config to check if Popular feed already harvested... ")
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return pop_d
def find_user(self, username):
data = self.api.user_search(username, count=20)
print data
def find_followers(self, userid):
# first do a lookup and see if the latest set if followers has allready been found
follower_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = 0
# let's see if the object has some nice things in it.
try:
config_returned = results["data"]["service_instagram_config"]
friends_number = int(config_returned["friends_list_size"][0]["@value"])
followers_number = int(config_returned["followers_list_size"][0]["@value"])
since_id = int(config_returned["since_id"][0]["@value"])
logging.info("Found the instagram Config Object.")
except:
# print sys.exc_info()
pass
followed_by = self.api.user_followed_by(userid)[0]
# print "followed_by length: "+str(len(followed_by))
# print str(followed_by)
# see if the number is different, if it is, then update.. could be nicer than this, but for now, it will work (ish)
if (len(followed_by) != followers_number) or (followers_number == 0):
followers_number = len(followed_by)
objects_to_insert = []
current_timestamp = str(time.time()).split(".")[0] # str(datetime.now())
timestamp = str(datetime.now().isoformat("T")).split(".")[0]
uniq_id = "instagram_follower_network_for_user_me" # +self.instagram_username
followed_by_obj = {
"@id": uniq_id,
"app_object": appid,
"instagram_username": self.instagram_username,
"instagram_user_id": self.instagram_user_id,
"timestamp": timestamp,
"followed_by_count": len(followed_by),
}
followers_ids = []
for follower in followed_by:
# print follower.username
uniq_id = "instagram_user_" + str(follower.username)
follower_obj = {
"@id": uniq_id,
"app_object": appid,
"type": "user",
"instagram_username": str(follower.username),
"timestamp": timestamp,
}
objects_to_insert.append(follower_obj)
# we can add this to the followed_by_obj later
followers_ids.append(uniq_id)
# link the followers for me
followed_by_obj["follower_ids"] = followers_ids
# print followed_by_objs
# for friend in friends_list:
# print friend
# now append the results
def update_cb(re):
logging.debug("network harvest async worked {0}".format(re))
follower_d.callback(True)
def update_cb_fail(re):
logging.error("network harvest async failed {0}".format(re))
follower_d.errback
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id,
}
objects_to_insert.append(followed_by_obj)
# objects_to_insert.append(followers)
objects_to_insert.append(instagram_config_obj)
self.insert_object_to_indx(objects_to_insert).addCallbacks(update_cb, update_cb_fail)
else:
follower_d.callback(True)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info("Searching for instagram_config to check if network already harvested... ")
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return follower_d
# print followed_by
def find_friends(self, userid):
friends_d = Deferred()
def found_cb(results):
friends_number = 0
followers_number = 0
since_id = 0
# let's see if the object has some nice things in it.
try:
config_returned = results["data"]["service_instagram_config"]
friends_number = int(config_returned["friends_list_size"][0]["@value"])
followers_number = int(config_returned["followers_list_size"][0]["@value"])
since_id = int(config_returned["since_id"][0]["@value"])
logging.info("Found the instagram Config Object.")
except:
# print sys.exc_info()
pass
friends_by_list = self.api.user_follows(userid)[0]
if (len(friends_by_list) != friends_number) or (friends_number == 0):
friends_number = len(friends_by_list)
objects_to_insert = []
current_timestamp = str(time.time()).split(".")[0] # str(datetime.now())
timestamp = str(datetime.now().isoformat("T")).split(".")[0]
uniq_id = "instagram_friends_network_for_user_me" # +self.instagram_username
friends_by_obj = {
"@id": uniq_id,
"app_object": appid,
"instagram_username": self.instagram_username,
"instagram_user_id": self.instagram_user_id,
"timestamp": timestamp,
"followed_by_count": len(friends_by_list),
}
friends_ids = []
for friend in friends_by_list:
# print follower.username
uniq_id = "instagram_user_" + str(friend.username)
friend_obj = {
"@id": uniq_id,
"app_object": appid,
"type": "user",
"instagram_username": str(friend.username),
"timestamp": timestamp,
}
objects_to_insert.append(friend_obj)
# we can add this to the followed_by_obj later
friends_ids.append(uniq_id)
friends_by_obj["friends_ids"] = friends_ids
# print friends_by_objs
# for friend in friends_list:
# print friend
# now append the results
def update_cb(re):
logging.debug("network harvest async worked {0}".format(re))
friends_d.callback(True)
def update_cb_fail(re):
logging.error("network harvest async failed {0}".format(re))
friends_d.errback
instagram_config_obj = {
"@id": "service_instagram_config",
"app_object": appid,
"type": "config",
"config_last_updated_at": timestamp,
"config_for_instagram_user": self.instagram_username,
"friends_list_generated_at": timestamp,
"follower_list_generated_at": timestamp,
"friends_list_size": friends_number,
"followers_list_size": followers_number,
"since_id": since_id,
}
objects_to_insert.append(friends_by_obj)
# objects_to_insert.append(followers)
objects_to_insert.append(instagram_config_obj)
self.insert_object_to_indx(objects_to_insert).addCallbacks(update_cb, update_cb_fail)
else:
friends_d.callback(True)
def error_cb(re):
found_cb()
def_search = Deferred()
find_instagram_config = {"@id": "service_instagram_config"}
logging.info("Searching for instagram_config to check if network already harvested... ")
def_search = self.indx_con.query(json.dumps(find_instagram_config))
def_search.addCallbacks(found_cb, error_cb)
return friends_d
# print followed_by
def subscribe_to_objects_by_tag(self, search_terms):
def process_tag_update(update):
print update
reactor = subscriptions.SubscriptionsReactor()
reactor.register_callback(subscriptions.SubscriptionType.TAG, process_tag_update)
self.api.create_subscription(
object="tag", object_id=search_terms, aspect="media", callback_url="http://*****:*****@version"]
logging.debug(
"Succesfully Updated INDX with Objects in update_cb, new diff version of {0}".format(self.version)
)
# logging.debug("Inserted Object into INDX: ".format(resp))
update_d.callback(True)
# return update_d
# time.sleep(2)
def exception_cb(e, service=self, obj=obj):
logging.debug("Exception Inserting into INDX, probably wrong version given")
if isinstance(e.value, urllib2.HTTPError): # handle a version incorrect error, and update the version
if e.value.code == 409: # 409 Obsolete
response = e.value.read()
json_response = json.loads(response)
service.version = json_response["@version"]
logging.debug("INDX insert error in Instagram Service Object: " + str(response))
try:
service.indx_con.update(service.version, obj).addCallbacks(update_cb, exception_cb)
# logging.debug('Twitter Service - Successfully added Objects into Box')
except:
logging.error("Instagram Service, error on insert {0}".format(response))
update_d.errback(e.value)
else:
logging.error("Instagram Service Unknow error: {0}".format(e.value.read()))
update_d.errback(e.value)
else:
logging.error("Error updating INDX: {0}".format(e.value))
update_d.errback(e.value)
logging.debug(
"in Instagram - Trying to insert into indx...Current diff version: {0} and objects (len) given {1}".format(
self.version, len(obj)
)
)
self.indx_con.update(self.version, obj).addCallbacks(update_cb, exception_cb)
return update_d
def InstagramProcces(self):
self.aceptar.setCursor(QCursor(Qt.ForbiddenCursor))
self.update_progressbar(10)
access_token = self.lnToken.text()
client_secret = self.lnAcces.text()
user_id=self.lnId.text()
if not access_token or not client_secret:
QMessageBox.information(self, "Empty values", "Complete mandatory items <access_token> and <client_secret>", QMessageBox.AcceptRole)
return
try:
api = InstagramAPI(access_token=access_token, client_secret=client_secret)
#Search recent media with Tag
if self.TypeSearch=="hashtags":
count=self.sp_count.value()
tag=self.ln_tags.text()
if tag=="":
QMessageBox.information(self, "Empty values", "Tag value is empty", QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
tag_search, next_tag = api.tag_search(tag)
tag_recent_media, next = api.tag_recent_media(count,tag_name=tag_search[0].name)
if len(tag_recent_media)==0:return self.Checklength()
categorized,layer=self.CreateShape()
for tag_media in tag_recent_media:
self.AddFeatures(tag_media,layer,categorized)
#Search recent media with Location
elif self.TypeSearch=="coords":
lat=self.ln_lat.text()
lng=self.ln_lng.text()
distance=self.sp_distance.value()
location_search =api.media_search(lat=str(lat),lng=str(lng), distance=int(distance))
if len(location_search)==0:return self.Checklength()
categorized,layer=self.CreateShape()
for location in location_search:
self.AddFeatures(location,layer,categorized)
#Search recent media with user
elif self.TypeSearch=="user":
if self.lnId.text()=="":
QMessageBox.information(self, "Empty values", "User name value is empty", QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
user_name=self.lnId.text()
user_search = api.user_search(user_name)
if len(user_search)==0:return self.Checklength()
layer=self.CreateShapeMin()
for user in user_search:
self.AddFeaturesMin(user,layer)
#Search user recent
elif self.TypeSearch=="user_recent":
recent_media, next = api.user_recent_media()
if len(recent_media)==0:return self.Checklength()
categorized,layer=self.CreateShape()
for media in recent_media:
self.AddFeatures(media,layer,categorized)
#Search User Media Feed
elif self.TypeSearch=="user_media":
media_feed, next = api.user_media_feed()
if len(media_feed)==0:return self.Checklength()
categorized,layer=self.CreateShape()
for media in media_feed:
self.AddFeatures(media,layer,categorized)
#Search User follow
elif self.TypeSearch=="user_follow":
if self.lnId.text()=="":
QMessageBox.information(self, "Empty values", "User ID value is empty", QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
user_follows, next = api.user_follows(user_id)
if len(user_follows)==0:return self.Checklength()
layer=self.CreateShapeMin()
for user in user_follows:
self.AddFeaturesMin(user,layer)
#Search Location recent
elif self.TypeSearch=="location_recent":
if self.ln_loc_id.text()=="":
QMessageBox.information(self, "Empty values", "Location ID value is empty", QMessageBox.AcceptRole)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.update_progressbar(0)
return
location_id=int(self.ln_loc_id.text())
recent_media, next = api.location_recent_media(location_id=location_id)
if len(recent_media)==0:return self.Checklength()
categorized,layer=self.CreateShape()
for media in recent_media:
self.AddFeatures(media,layer,categorized)
#Search recent popular
elif self.TypeSearch=="popular":
media_search = api.media_popular()
if len(media_search)==0:return self.Checklength()
categorized,layer=self.CreateShape()
for media in media_search:
self.AddFeatures(media,layer,categorized)
#Save layer in output path
QgsVectorFileWriter.writeAsVectorFormat(layer,self.settings.value("instagram2qgis/outpath"), "CP1250", None, "ESRI Shapefile")
self.update_progressbar(100)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
self.reject()
except Exception, e:
self.iface.messageBar().pushMessage("Error: ", "fail to load photos: "+str(e),level=QgsMessageBar.CRITICAL, duration=20)
self.aceptar.setCursor(QCursor(Qt.PointingHandCursor))
response = requests.get(url, stream=True)
if response.status_code == 200:
with open(target_filename, 'wb') as image_file:
for chunk in response.iter_content():
image_file.write(chunk)
if __name__ == '__main__':
import arrow
print arrow.now()
make_image_dir()
access_token = get_access_token()
instagram_api = InstagramAPI(access_token=access_token)
media_feed, _ = instagram_api.user_media_feed(count=1)
for media in media_feed:
media_filename = get_media_filename(media)
try:
image = Image.open(media_filename)
except IOError:
print 'downloading...'
image_filename = download_media(media, media_filename)
image = Image.open(media_filename)
else:
print 'cache hit'
unicode_image = UnicodeImage(image, width=200)
print unicode_image
class InstagramAccount(Account):
def __init__(self, client_id=None,client_secret=None,redirect_url=None,access_token=None,name=None,ty=None,**kwargs):
self.client_id = client_id
self.client_secret = client_secret
self.redirect = redirect_url
self.name = name
self.ty = ty
if access_token:
self.access_token = access_token
self.api = InstagramAPI(access_token=access_token)
else:
self.api = InstagramAPI(client_id=client_id,client_secret=client_secret,redirect_uri=redirect_url)
url = self.api.get_authorize_login_url(scope=['basic','likes','comments','relationships'])
print 'This account needs to be authenticated. Visit this url:'
print url
code = raw_input('Please enter the result code:').strip()
self.access_token, user_info = self.api.exchange_code_for_access_token(code)
db.instagram.update({'name':self.name},{'$set':{'access_token':self.access_token}})
self.api = InstagramAPI(access_token = access_token)
self.uid = self._get_uid(self.name)
def log(self,action,details):
Account.log(self,'instagram',action,details)
# Pick a popular thing and like it.
def like_popular(self):
self.log("like-popular",str(datetime.today()))
popular = self.api.media_popular(count='20')
for i in xrange(8):
p = random.choice(popular)
self.api.like_media(p.id)
# Follow someone.
def follow(self,un):
uid = self._get_uid(un)
# Bug in the official API call for this one. Needs direct HTTP
payload = {'ACCESS_TOKEN':self.access_token,'action':'follow'}
r = requests.post('https://api.instagram.com/v1/users/'+uid+'/relationship?access_token='+self.access_token,data=payload)
return r
# Follow a friend of a friend.
def follow_branch(self):
friends = self.api.user_follows(self.uid)
f = random.choice(friends[0])
other_friends = self.api.user_follows(f.id)
f2 = random.choice(other_friends[0])
self.log("follow-branch",str(datetime.today())+','+f2.username)
self.follow(f2.username)
return f2
# make a generic comment
# for now these comments are just positive
def generic_comment_friend(self):
#1. pick a friend
friends = self.api.user_follows(self.uid)[0]
f = random.choice(friends)
#2. pick a dumb comment
comment = random.choice(POSITIVE)
#3. pick something they posted
recent = self.api.user_recent_media(f.id)
print recent
post = random.choice(recent)
self.log("generic-comment-friend",str(datetime.today())+','+str(post)+','+str(comment))
#4. make a dumb comment on their dumb post
self.api.create_media_comment(post.id,comment)
return (post,comment)
def generic_comment_feed(self):
comment = random.choice(POSITIVE)
post = random.choice(self.api.user_media_feed()[0])
self.log("generic-comment-friend",str(datetime.today())+','+str(post)+','+str(comment))
self.api.create_media_comment(post.id,comment)
# like something a friend posted recently
def like_friend(self):
friends = self.api.user_follows(self.uid)[0]
f = random.choice(friends)
recent = self.api.user_recent_media(user_id=f.id,count=20)
self.log("like-friends-post",str(datetime.today())+','+f.username)
post = random.choice(recent[0])
self.api.like_media(post.id)
return post
# Helper to turn a username into a user id
def _get_uid(self,un):
uid = self.api.user_search(q=un)
uid = uid[0]
uid = uid.id
return uid
import requests
import StringIO
from django.conf import settings
from instagram.client import InstagramAPI
api = InstagramAPI(access_token=settings.INSTAGRAM_ACCESS_TOKEN)
recent_media = api.user_media_feed(count=10)
for media in recent_media:
response = requests.get(media.images.standard_resolution.url)
image = StringIO.StringIO(response.content)
class InstagramAccount(Account):
def __init__(self,
client_id=None,
client_secret=None,
redirect_url=None,
access_token=None,
name=None,
ty=None,
**kwargs):
self.client_id = client_id
self.client_secret = client_secret
self.redirect = redirect_url
self.name = name
self.ty = ty
if access_token:
self.access_token = access_token
self.api = InstagramAPI(access_token=access_token)
else:
self.api = InstagramAPI(client_id=client_id,
client_secret=client_secret,
redirect_uri=redirect_url)
url = self.api.get_authorize_login_url(
scope=['basic', 'likes', 'comments', 'relationships'])
print 'This account needs to be authenticated. Visit this url:'
print url
code = raw_input('Please enter the result code:').strip()
self.access_token, user_info = self.api.exchange_code_for_access_token(
code)
db.instagram.update({'name': self.name},
{'$set': {
'access_token': self.access_token
}})
self.api = InstagramAPI(access_token=access_token)
self.uid = self._get_uid(self.name)
def log(self, action, details):
Account.log(self, 'instagram', action, details)
# Pick a popular thing and like it.
def like_popular(self):
self.log("like-popular", str(datetime.today()))
popular = self.api.media_popular(count='20')
for i in xrange(8):
p = random.choice(popular)
self.api.like_media(p.id)
# Follow someone.
def follow(self, un):
uid = self._get_uid(un)
# Bug in the official API call for this one. Needs direct HTTP
payload = {'ACCESS_TOKEN': self.access_token, 'action': 'follow'}
r = requests.post('https://api.instagram.com/v1/users/' + uid +
'/relationship?access_token=' + self.access_token,
data=payload)
return r
# Follow a friend of a friend.
def follow_branch(self):
friends = self.api.user_follows(self.uid)
f = random.choice(friends[0])
other_friends = self.api.user_follows(f.id)
f2 = random.choice(other_friends[0])
self.log("follow-branch", str(datetime.today()) + ',' + f2.username)
self.follow(f2.username)
return f2
# make a generic comment
# for now these comments are just positive
def generic_comment_friend(self):
#1. pick a friend
friends = self.api.user_follows(self.uid)[0]
f = random.choice(friends)
#2. pick a dumb comment
comment = random.choice(POSITIVE)
#3. pick something they posted
recent = self.api.user_recent_media(f.id)
print recent
post = random.choice(recent)
self.log("generic-comment-friend",
str(datetime.today()) + ',' + str(post) + ',' + str(comment))
#4. make a dumb comment on their dumb post
self.api.create_media_comment(post.id, comment)
return (post, comment)
def generic_comment_feed(self):
comment = random.choice(POSITIVE)
post = random.choice(self.api.user_media_feed()[0])
self.log("generic-comment-friend",
str(datetime.today()) + ',' + str(post) + ',' + str(comment))
self.api.create_media_comment(post.id, comment)
# like something a friend posted recently
def like_friend(self):
friends = self.api.user_follows(self.uid)[0]
f = random.choice(friends)
recent = self.api.user_recent_media(user_id=f.id, count=20)
self.log("like-friends-post", str(datetime.today()) + ',' + f.username)
post = random.choice(recent[0])
self.api.like_media(post.id)
return post
# Helper to turn a username into a user id
def _get_uid(self, un):
uid = self.api.user_search(q=un)
uid = uid[0]
uid = uid.id
return uid
