ips_to_maps.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Use Tautulli draw a map connecting Server to Clients based on IP addresses.

optional arguments:
  -h, --help            show this help message and exit
  -m , --map            Map location. choices: (NA, EU, World, Geo)
                        (default: NA)
  -c [], --count []     How many IPs to attempt to check.
                        (default: 2)
  -u  [ ...], --users  [ ...]
                        Space separated list of case sensitive names to process. Allowed names are:
                        {List of Users}
                        (default: all)
  -i  [ ...], --ignore  [ ...]
                        Space separated list of case sensitive names to process. Allowed names are:
                        {List of Users}
                        (default: None)
  -f  [ ...], --filename  [ ...]
                        Filename of map. None will not save. (default: Map_YYYYMMDD-HHMMSS)
  -j [], --json []      Filename of json file to use.
                        (choices: {List of .json files in current dir})
  --headless            Run headless.


"""
from __future__ import print_function
from __future__ import unicode_literals

from builtins import zip
from builtins import str
from builtins import range
from builtins import object
import requests
import sys
import json
import os
from collections import OrderedDict
import argparse
# import numpy as np
import time
import webbrowser
import re

# ## EDIT THESE SETTINGS ##
TAUTULLI_APIKEY = ''  # Your Tautulli API key
TAUTULLI_URL = 'http://localhost:8181/'  # Your Tautulli URL

# Replace LAN IP addresses that start with the LAN_SUBNET with a WAN IP address
# to retrieve geolocation data. Leave REPLACEMENT_WAN_IP blank for no replacement.
LAN_SUBNET = ('10.10', '127.0.0')
REPLACEMENT_WAN_IP = ''

# Enter Friendly name for Server ie 'John Smith'
SERVER_FRIENDLY = 'Server'

# Server location information. Find this information on your own.
# If server plot is out of scope add print(geo_lst) after ut.user_id loop ~line 151 to find the error
SERVER_LON = ''
SERVER_LAT = ''
SERVER_CITY = ''
SERVER_STATE = ''
SERVER_PLATFORM = 'Server'

DEFAULT_COLOR = '#A96A1C'  # Plex Orange?

PLATFORM_COLORS = {'Android': '#a4c639',  # Green
                   'Roku': '#800080',  # Purple
                   'Chromecast': '#ffff00',  # Yellow
                   'Xbox One': '#ffffff',  # White
                   'Chrome': '#ff0000',  # Red
                   'Playstation 4': '#0000ff',  # Blue
                   'iOS': '#8b4513',  # Poop brown
                   'Samsung': '#0c4da2',  # Blue
                   'Windows': DEFAULT_COLOR,
                   'Xbox 360 App': DEFAULT_COLOR}

# title of map
title_string = "Location of Plex users based on ISP data"


def clean_up_text(title):
    cleaned = re.sub('\W+', ' ', title)
    return cleaned


class GeoData(object):
    def __init__(self, data=None):
        data = data or {}
        self.continent = data.get('continent', 'N/A')
        self.country = data.get('country', 'N/A')
        self.region = clean_up_text(data.get('region', 'N/A'))
        self.city = clean_up_text(data.get('city', 'N/A'))
        self.postal_code = data.get('postal_code', 'N/A')
        self.timezone = data.get('timezone', 'N/A')
        self.latitude = data.get('latitude', 'N/A')
        self.longitude = data.get('longitude', 'N/A')
        self.accuracy = data.get('accuracy', 'N/A')


class UserIPs(object):
    def __init__(self, data=None):
        d = data or {}
        self.ip_address = d['ip_address']
        self.friendly_name = clean_up_text(d['friendly_name'])
        self.play_count = d['play_count']
        self.platform = d['platform']


def get_users_tables(users='', length=''):
    # Get the users list from Tautulli

    if length:
        payload = {'apikey': TAUTULLI_APIKEY,
                   'cmd': 'get_users_table',
                   'length': length}
    else:
        payload = {'apikey': TAUTULLI_APIKEY,
                   'cmd': 'get_users_table'}

    try:
        r = requests.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = r.json()
        res_data = response['response']['data']['data']
        if not length and not users:
            # Return total user count
            return response['response']['data']['recordsTotal']
        else:
            if users == 'all':
                return [d['user_id'] for d in res_data]
            elif users == 'friendly_name':
                return [d['friendly_name'] for d in res_data]
            else:
                return [d['user_id'] for user in users for d in res_data if user == d['friendly_name']]

    except Exception as e:
        sys.stderr.write("Tautulli API 'get_users_tables' request failed: {0}.".format(e))


def get_users_ips(user_id, length):
    # Get the user IP list from Tautulli
    payload = {'apikey': TAUTULLI_APIKEY,
               'cmd': 'get_user_ips',
               'user_id': user_id}

    try:
        r = requests.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = r.json()
        res_data = response['response']['data']['data']
        return [UserIPs(data=d) for d in res_data]
    except Exception as e:
        sys.stderr.write("Tautulli API 'get_users_ips' request failed: {0}.".format(e))


def get_geoip_info(ip_address=''):
    # Get the geo IP lookup from Tautulli
    payload = {'apikey': TAUTULLI_APIKEY,
               'cmd': 'get_geoip_lookup',
               'ip_address': ip_address}

    try:
        r = requests.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = r.json()
        if response['response']['result'] == 'success':
            data = response['response']['data']
            if data.get('error'):
                raise Exception(data['error'])
            else:
                sys.stdout.write("Successfully retrieved geolocation data.")
                return GeoData(data=data)
        else:
            raise Exception(response['response']['message'])
    except Exception as e:
        sys.stderr.write("Tautulli API 'get_geoip_lookup' request failed: {0}.".format(e))
        pass


def add_to_dictlist(d, key, val):
    if key not in d:
        d[key] = [val]
    else:
        d[key].append(val)
    for x in d[key]:
        if (val['region'], val['city']) == (x['region'], x['city']):
            x['location_count'] += 1


def get_geo_dict(length, users):
    geo_dict = {SERVER_FRIENDLY: [{'lon': SERVER_LON, 'lat': SERVER_LAT, 'city': SERVER_CITY, 'region': SERVER_STATE,
                                   'ip': REPLACEMENT_WAN_IP, 'play_count': 0, 'platform': SERVER_PLATFORM,
                                   'location_count': 0}]}

    for i in get_users_tables(users):
        user_ip = get_users_ips(user_id=i, length=length)
        city_cnt = 0
        for a in user_ip:
            try:
                ip = a.ip_address
                if ip.startswith(LAN_SUBNET) and REPLACEMENT_WAN_IP:
                    ip = REPLACEMENT_WAN_IP

                g = get_geoip_info(ip_address=ip)

                add_to_dictlist(geo_dict, a.friendly_name, {'lon': str(g.longitude), 'lat': str(g.latitude),
                                                            'city': str(g.city), 'region': str(g.region),
                                                            'ip': ip, 'play_count': a.play_count,
                                                            'platform': a.platform, 'location_count': city_cnt})
            except AttributeError:
                print('User: {} IP: {} caused error in geo_dict.'.format(a.friendly_name, a.ip_address))
                pass
            except Exception as e:
                print('Error here: {}'.format(e))
                pass
    return geo_dict


def get_geojson_dict(user_locations):
    locs = []
    for username, locations in user_locations.items():
        for location in locations:
            try:
                locs.append({
                    "type": "Feature",
                    "properties": {
                        "User": username,
                        "City": location['city'],
                        "State": location['region'],
                        "IP": location['ip'],
                        "Count": location['play_count']
                    },
                    "geometry": {
                        "type": "Point",
                        "coordinates": [
                            float(location['lon']), float(location['lat'])
                        ]
                    }
                })

                locs.append({
                    "type": "Feature",
                    "properties": {
                        "geodesic": "true",
                        "geodesic_steps": 50,
                        "geodesic_wrap": "true"
                    },
                    "geometry": {
                        "type": "LineString",
                        "coordinates": [
                            [float(location['lon']), float(location['lat'])],
                            [float(SERVER_LON), float(SERVER_LAT)],
                        ]
                    }
                })
            except ValueError:
                pass
    return {
        "type": "FeatureCollection",
        "features": locs
    }


def draw_map(map_type, geo_dict, filename, headless, leg_choice):
    import matplotlib as mpl
    if headless:
        mpl.use("Agg")
    import matplotlib.pyplot as plt
    from mpl_toolkits.basemap import Basemap

    # ## Map stuff ##
    plt.figure(figsize=(16, 9), dpi=100, frameon=False)
    lon_r = 0
    lon_l = 0

    if map_type == 'NA':
        m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-54, urcrnrlat=55, projection='lcc', resolution='l',
                    lat_1=32, lat_2=45, lon_0=-95)
        lon_r = 66.0
        lon_l = -124.0
    elif map_type == 'EU':
        m = Basemap(llcrnrlon=-15., llcrnrlat=20, urcrnrlon=75., urcrnrlat=70, projection='lcc', resolution='l',
                    lat_1=30, lat_2=60, lon_0=35.)
        lon_r = 50.83
        lon_l = -69.03

    elif map_type == 'World':
        m = Basemap(projection='robin', lat_0=0, lon_0=-100, resolution='l', area_thresh=100000.0)
        # m.drawmeridians(np.arange(0, 360, 30))
        # m.drawparallels(np.arange(-90, 90, 30))
        lon_r = 180
        lon_l = -180.0

    # remove line in legend
    mpl.rcParams['legend.handlelength'] = 0
    m.drawmapboundary(fill_color='#1F1F1F')
    m.drawcoastlines()
    m.drawstates()
    m.drawcountries()
    m.drawlsmask(land_color='#3C3C3C', ocean_color='#1F1F1F')

    for key, values in geo_dict.items():
        # add Accuracy as plot/marker size, change play count to del_s value.
        for data in values:
            if key == SERVER_FRIENDLY:
                color = '#FFAC05'
                marker = '*'
                markersize = 8
                zord = 3
                alph = 1
            else:
                if data['platform'] in PLATFORM_COLORS:
                    color = PLATFORM_COLORS[data['platform']]
                else:
                    color = DEFAULT_COLOR
                    print('Platform: {} is missing from PLATFORM_COLORS. Using DEFAULT_COLOR.'.format(data['platform']))
                marker = '.'
                if data['play_count'] >= 100:
                    markersize = (data['play_count'] * .01)
                elif data['play_count'] <= 2:
                    markersize = 1
                else:
                    markersize = 2
                zord = 2
                alph = 0.4
            px, py = m(float(data['lon']), float(data['lat']))
            x, y = m([float(data['lon']), float(SERVER_LON)], [float(data['lat']), float(SERVER_LAT)])
            legend = 'Location: {}, {},  User: {}\nPlatform: {}, IP: {}, Play Count: {}'.format(
                data['city'], data['region'], key, data['platform'], data['ip'], data['play_count'])
            # Keeping lines inside the Location. Plots outside Location will still be in legend

            if float(data['lon']) != float(SERVER_LON) and float(data['lat']) != float(SERVER_LAT) and \
                    lon_l < float(data['lon']) < lon_r:
                # Drawing lines from Server location to client location
                if data['location_count'] > 1:
                    lines = m.plot(x, y, marker=marker, color=color, markersize=0,
                                   label=legend, alpha=.6, zorder=zord, linewidth=2)
                    # Adding dash sequence to 2nd, 3rd, etc lines from same city,state
                    for line in lines:
                        line.set_solid_capstyle('round')
                        dashes = [x * data['location_count'] for x in [5, 8, 5, 8]]
                        line.set_dashes(dashes)

                else:
                    m.plot(x, y, marker=marker, color=color, markersize=0, label=legend, alpha=.4, zorder=zord,
                           linewidth=2)

            m.plot(px, py, marker=marker, color=color, markersize=markersize, label=legend, alpha=alph, zorder=zord)

    if leg_choice:
        handles, labels = plt.gca().get_legend_handles_labels()
        idx = labels.index('Location: {}, {},  User: {}\nPlatform: {}, IP: {}, Play Count: {}'.
                           format(SERVER_CITY, SERVER_STATE, SERVER_FRIENDLY, SERVER_PLATFORM, REPLACEMENT_WAN_IP,
                                  0))
        labels = labels[idx:] + labels[:idx]
        handles = handles[idx:] + handles[:idx]
        by_label = OrderedDict(list(zip(labels, handles)))

        leg = plt.legend(list(by_label.values()), list(by_label.keys()), fancybox=True, fontsize='x-small',
                         numpoints=1, title="Legend", labelspacing=1., borderpad=1.5, handletextpad=2.)
        if leg:
            lleng = len(leg.legendHandles)
            for i in range(1, lleng):
                leg.legendHandles[i]._legmarker.set_markersize(10)
                leg.legendHandles[i]._legmarker.set_alpha(1)
            leg.get_title().set_color('#7B777C')
            leg.set_draggable(state=True)
            leg.get_frame().set_facecolor('#2C2C2C')
            for text in leg.get_texts():
                plt.setp(text, color='#A5A5A7')

    plt.title(title_string)
    if filename:
        plt.savefig('{}.png'.format(filename))
        print('Image saved as: {}.png'.format(filename))
    if not headless:
        mng = plt.get_current_fig_manager()
        mng.window.state('zoomed')
        plt.show()


if __name__ == '__main__':

    timestr = time.strftime("%Y%m%d-%H%M%S")
    user_count = get_users_tables()
    user_lst = sorted(get_users_tables('friendly_name', user_count))
    json_check = sorted([f for f in os.listdir('.') if os.path.isfile(f) and f.endswith(".json")],
                        key=os.path.getmtime)
    parser = argparse.ArgumentParser(description="Use PlexPy to draw map of user locations base on IP address.",
                                     formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument('-m', '--map', default='NA', choices=['NA', 'EU', 'World', 'Geo'], metavar='',
                        help='Map location. choices: (%(choices)s) \n(default: %(default)s)')
    parser.add_argument('-c', '--count', nargs='?', type=int, default=2, metavar='',
                        help='How many IPs to attempt to check. \n(default: %(default)s)')
    parser.add_argument('-u', '--users', nargs='+', type=str, default='all', choices=user_lst, metavar='',
                        help='Space separated list of case sensitive names to process. Allowed names are: \n'
                             '%(choices)s \n(default: %(default)s)')
    parser.add_argument('-i', '--ignore', nargs='+', type=str, default=None, choices=user_lst, metavar='',
                        help='Space separated list of case sensitive names to process. Allowed names are: \n'
                             '%(choices)s \n(default: %(default)s)')
    parser.add_argument('-f', '--filename', nargs='+', type=str, default='Map_{}'.format(timestr), metavar='',
                        help='Filename of map. None will not save. \n(default: %(default)s)')
    parser.add_argument('-j', '--json', nargs='?', type=str, choices=json_check, metavar='',
                        help='Filename of json file to use. \n(choices: %(choices)s)')

    parser.add_argument('--headless', action='store_true', help='Run headless.')

    parser.add_argument('--legend', dest='legend', action='store_true', help='Toggle on legend.')
    parser.add_argument('--no_legend', dest='legend', action='store_false', help='Toggle off legend.')
    parser.set_defaults(legend=True)

    opts = parser.parse_args()
    if opts.json:
        if opts.filename == ['None']:
            filename = None
        else:
            filename = '{}'.format(''.join(opts.filename))
        print('Using existing .json file to map.')
        with open(''.join(opts.json)) as json_data:
            geo_json = json.load(json_data)
    else:
        # print(opts)
        if opts.ignore and opts.users == 'all':
            users = [x for x in user_lst if x not in opts.ignore]
        else:
            users = opts.users
        if opts.filename == ['None']:
            filename = None
            json_file = '{}.json'.format(timestr)
        else:
            filename = '{}'.format(''.join(opts.filename))
            json_file = '{}.json'.format(''.join(opts.filename))
        geo_json = get_geo_dict(opts.count, users)
        with open(json_file, 'w') as fp:
            json.dump(geo_json, fp, indent=4, sort_keys=True)

    if opts.map == 'Geo':
        geojson = get_geojson_dict(geo_json)
        print("\n")
        geojson_file = '{}.geojson'.format(''.join(opts.filename))
        with open(geojson_file, 'w') as fp:
            json.dump(geojson, fp, indent=4, sort_keys=True)

    else:
        draw_map(opts.map, geo_json, filename, opts.headless, opts.legend)