instagram_tool

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from requests import get
from time import sleep
from math import pi, cos, sqrt
from datetime import datetime
from winsound import Beep as beep
from sys import exit


api_key = "000000000.0000xx0.00x0000000xx00x0x00xxx0x0xxxx0x0"

offset = 24 * 60 * 60
radius = 1000
output_border = 60


if api_key == "000000000.0000xx0.00x0000000xx00x0x00xxx0x0xxxx0x0":
    print 'YOU NEED REAL INSTAGRAM ACCESS TOKEN'
    exit()


def get_user_id(username):
    answer = get('https://api.instagram.com/v1/users/search?q=' + username + '&access_token=' + api_key, verify=True).json()
    if answer['data'] != []:
        return answer['data'][0]['id']


def get_data_from_json(json_text):
    answer = list()
    for element in json_text['data']:
        answer.append(element)
    return answer


def get_media(username):
    answer = list()
    user_id = get_user_id(username)
    data = get('https://api.instagram.com/v1/users/' + user_id + '/media/recent/?access_token=' + api_key, verify=True).json()
    try:
        if data[u'meta'][u'code'] == 200:
            if data[u'pagination'] == {}:
                answer += get_data_from_json(data)
            else:
                answer += get_data_from_json(data)
                while True:
                    if data[u'pagination'] != {}:
                        data = get(data[u'pagination'][u'next_url'], verify=True).json()
                        answer += get_data_from_json(data)
                    else:
                        break
        else:
            answer = list()
    except:
        answer = list()
    return answer


def get_users_from_json(data_input):
    data_answer = list()
    for i in xrange(len(data_input[u'data'])):
        data_answer.append(data_input[u'data'][i][u'username'])
    return data_answer


def get_insta_followers(seed_user):
    answer = list()
    try:
        seed_user_id = get_user_id(seed_user)
        data = get("https://api.instagram.com/v1/users/" + seed_user_id + "/followed-by?access_token=" + api_key, verify=True).json()
        if data[u'meta'][u'code'] == 200:
            if data[u'pagination'] == {}:
                answer += get_users_from_json(data)
            else:
                answer += get_users_from_json(data)
                while True:
                    if data[u'pagination'] != {}:
                        data = get(data[u'pagination'][u'next_url'], verify=True).json()
                        answer += get_users_from_json(data)
                    else:
                        break
        else:
            answer = list()
    except:
        answer = list()
    return answer


def get_insta_friends(seed_user):
    answer = list()
    try:
        seed_user_id = get_user_id(seed_user)
        data = get("https://api.instagram.com/v1/users/" + seed_user_id + "/follows?access_token=" + api_key, verify=True).json()
        if data[u'meta'][u'code'] == 200:
            if data[u'pagination'] == {}:
                answer += get_users_from_json(data)
            else:
                answer += get_users_from_json(data)
                while True:
                    if data[u'pagination'] != {}:
                        data = get(data[u'pagination'][u'next_url'], verify=True).json()
                        answer += get_users_from_json(data)
                    else:
                        break
        else:
            answer = list()
    except:
        answer = list()
    return answer


def get_associated_users(username):
    return list(set(get_insta_followers(username) + get_insta_friends(username)))


def latitude_to_meters(lat):
    return float(lat) * float(111111)


def timestamp_to_time(timestamp):
    return datetime.fromtimestamp(float(timestamp)).strftime('%Y-%m-%d %H:%M:%S')


def longitude_to_meters(lon):
    return 6371000.0 * pi / 180 * cos(lon * pi / 180)


def is_in_one_zone(lat_target, long_target, lat_user, long_user, zone_radius):
    latitude_target_m = latitude_to_meters(lat_target)
    longitude_target_m = longitude_to_meters(long_target)
    latitude_user_m = latitude_to_meters(lat_user)
    longitude_user_m = longitude_to_meters(long_user)
    path = sqrt(abs(latitude_target_m - latitude_user_m) ** 2 + abs(longitude_target_m - longitude_user_m) ** 2)
    if path <= zone_radius:
        return True
    else:
        return False


def is_in_same_time(target_timestamp, friend_timestamp, time_offset):
    target_timestamp = int(target_timestamp)
    friend_timestamp = int(friend_timestamp)
    timestamps_range = range(target_timestamp - time_offset, target_timestamp + time_offset) + range(friend_timestamp - time_offset, friend_timestamp + time_offset)
    timestamp_set = list(set(timestamps_range))
    if len(timestamp_set) < len(timestamps_range):
        return True
    else:
        return False


def nice_printer(border, title, string):
    print title + ' ' * (border - len(title) - len(string)) + string


def get_target_dict(all_media):
    answer = dict()
    if all_media != []:
        answer.update({'username': all_media[0]['user']['username']})
        locations = []
        for element in all_media:
            str_location = str(element['location'])
            if str(element['location']) != u'None' and 'latitude' in str_location and 'longitude' in str_location and 'name' in str_location:
                locations.append({'placename': element['location']['name'], 'lat': element['location']['latitude'], 'long': element['location']['longitude'], 'time': element['created_time']})
        answer.update({'locations': locations})
        return answer


def get_users_dicts(all_users):
    answer = list()
    for user in all_users:
        user_media = get_media(user)
        answer.append(get_target_dict(user_media))
        sleep(1)
    return answer

target = str(raw_input('target user: '))

nice_printer(output_border, '[Target user]:', target)
target_media = get_media(target)

nice_printer(output_border, '[Found]:', str(len(target_media)) + ' media of target user')
all_users = get_associated_users(target)

beep(1000, 100)

clear_users = []
for raw_user in all_users:
    json_answer = get('https://api.instagram.com/v1/users/search?q=' + raw_user + '&access_token=' + api_key, verify=True).json()
    if json_answer['data'] != list():
        clear_users.append(raw_user)

nice_printer(output_border, '[Found]:', str(len(clear_users)) + ' friends of target user')

beep(1000, 100)

target_places = get_target_dict(target_media)
users_places = get_users_dicts(clear_users)

beep(1000, 100)


for target_place in target_places['locations']:
    for user_places in users_places:
        if str(user_places) != 'None':
            for place in user_places['locations']:
                zone_flag = is_in_one_zone(target_place['lat'], target_place['long'], place['lat'], place['long'], 1000)
                time_flag = is_in_same_time(target_place['time'], place['time'], 1000)
                if zone_flag and time_flag:
                    print '\n' + '#' * output_border
                    nice_printer(output_border, '[Users]:', target_places['username'] + ' and ' + user_places['username'])
                    print '-' * output_border
                    nice_printer(output_border, '[Place]:', target_place['placename'])
                    nice_printer(output_border, '', place['placename'])
                    print '-' * output_border
                    nice_printer(output_border, '[Time]:', str(timestamp_to_time(target_place['time'])))
                    nice_printer(output_border, '', str(timestamp_to_time(place['time'])))
                    print '-' * output_border
                    nice_printer(output_border, '[Coordinates]:', 'Target: [lat: ' + str(target_place['lat']) + ' long: ' + str(target_place['long']) + ']')
                    nice_printer(output_border, '', 'User:   [lat: ' + str(place['lat']) + ' long: ' + str(place['long']) + ']')
                    print '-' * output_border

beep(1000, 100)