Limiterr with timeout feature after activation of script

[blizzard93]

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

"""
Description: Limiting Plex users by plays, watches, or total time from Tautulli.
Author: Blacktwin, Arcanemagus
Requires: requests

Adding the script to Tautulli:
Taultulli > Settings > Notification Agents > Add a new notification agent >
 Script

Configuration:
Taultulli > Settings > Notification Agents > New Script > Configuration:

 Script Folder: /path/to/your/scripts
 Script File: ./limiterr.py (Should be selectable in a dropdown list)
 Script Timeout: {timeout}
 Description: Kill stream(s)
 Save

Triggers:
Taultulli > Settings > Notification Agents > New Script > Triggers:

 Check: Playback Start
 Save

Conditions:
Taultulli > Settings > Notification Agents > New Script > Conditions:

 Set Conditions: [{condition} | {operator} | {value} ]
 Save

Script Arguments:
Taultulli > Settings > Notification Agents > New Script > Script Arguments:

 Select: Playback Start, Playback Pause
 Arguments: --jbop SELECTOR --username {username}
            --sessionId {session_id} --notify notifierID
            --grandparent_rating_key {grandparent_rating_key}
            --limit plays=3 --delay 60
            --killMessage 'Your message here.'
            --today
            --sleep_hours

 Save
 Close
"""
from __future__ import print_function
from __future__ import unicode_literals

from builtins import range
import requests
import argparse
from datetime import datetime, timedelta
import sys
import os
from plexapi.server import PlexServer
from time import time as ttime
from time import sleep

import pickle                                   # new line, import pickle library to save time variable

TAUTULLI_URL = ''
TAUTULLI_APIKEY = ''
PLEX_URL = ''
PLEX_TOKEN = ''

# Environmental Variables
PLEX_URL = os.getenv('PLEX_URL', PLEX_URL)
PLEX_TOKEN = os.getenv('PLEX_TOKEN', PLEX_TOKEN)
TAUTULLI_URL = os.getenv('TAUTULLI_URL', TAUTULLI_URL)
TAUTULLI_APIKEY = os.getenv('TAUTULLI_APIKEY', TAUTULLI_APIKEY)
TAUTULLI_ENCODING = os.getenv('TAUTULLI_ENCODING', 'UTF-8')

# Using CONFIG file
# from plexapi.server import CONFIG
# PLEX_URL = CONFIG.data['auth'].get('server_baseurl', PLEX_URL)
# PLEX_TOKEN = CONFIG.data['auth'].get('server_token', PLEX_TOKEN)
# TAUTULLI_URL = CONFIG.data['auth'].get('tautulli_baseurl', TAUTULLI_URL)
# TAUTULLI_APIKEY = CONFIG.data['auth'].get('tautulli_apikey', TAUTULLI_APIKEY)

SUBJECT_TEXT = "Tautulli has killed a stream."
BODY_TEXT = "Killed session ID '{id}'. Reason: {message}"
BODY_TEXT_USER = "Killed {user}'s stream. Reason: {message}."
LIMIT_MESSAGE = 'Are you still watching or are you asleep? ' \
                'If not please wait ~{delay} seconds and try again.'

sess = requests.Session()
# Ignore verifying the SSL certificate
sess.verify = False  # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
    # Disable the warning that the request is insecure, we know that...
    import urllib3
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
lib_dict = {x.title: x.key for x in plex.library.sections()}

SELECTOR = ['watch', 'plays', 'time', 'limit']
TODAY = datetime.now()
unix_time = int(ttime())

def send_notification(subject_text, body_text, notifier_id):
    """Send a notification through Tautulli

    Parameters
    ----------
    subject_text : str
        The text to use for the subject line of the message.
    body_text : str
        The text to use for the body of the notification.
    notifier_id : int
        Tautulli Notification Agent ID to send the notification to.
    """
    payload = {'apikey': TAUTULLI_APIKEY,
               'cmd': 'notify',
               'notifier_id': notifier_id,
               'subject': subject_text,
               'body': body_text}

    try:
        req = sess.post(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = req.json()

        if response['response']['result'] == 'success':
            sys.stdout.write("Successfully sent Tautulli notification.\n")
        else:
            raise Exception(response['response']['message'])
    except Exception as e:
        sys.stderr.write(
            "Tautulli API 'notify' request failed: {0}.\n".format(e))
        return None

def get_activity(session_id=None):
    """Get the current activity on the PMS.

    Returns
    -------
    list
        The current active sessions on the Plex server.
    """
    payload = {'apikey': TAUTULLI_APIKEY,
               'cmd': 'get_activity'}
    if session_id:
        payload['session_id'] = session_id

    try:
        req = sess.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = req.json()

        if session_id:
            res_data = response['response']['data']
        else:
            res_data = response['response']['data']['sessions']
        return res_data

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

def get_history(username, start_date=None, section_id=None):
    """Get the Tautulli history.

    Parameters
    ----------
    username : str
        The username to gather history from.

    Optional
    ----------
    start_date : list ["YYYY-MM-DD", ...]
        The date in history to search.
    section_id : int
        The libraries numeric identifier

    Returns
    -------
    dict
        The total number of watches, plays, or total playtime.
    """
    payload = {'apikey': TAUTULLI_APIKEY,
               'cmd': 'get_history',
               'user': username}

    if start_date:
        payload['start_date'] = start_date

    if section_id:
        payload['section_id '] = section_id

    try:
        req = sess.get(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = req.json()

        res_data = response['response']['data']
        return res_data

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

def terminate_session(session_id, message, notifier=None, username=None):
    """Stop a streaming session.

    Parameters
    ----------
    session_id : str
        The session ID of the stream to terminate.
    message : str
        The message to display to the user when terminating a stream.
    notifier : int
        Notification agent ID to send a message to (the default is None).
    username : str
        The username for the terminated session (the default is None).
    """
    payload = {'apikey': TAUTULLI_APIKEY,
               'cmd': 'terminate_session',
               'session_id': session_id,
               'message': message}

    try:
        req = sess.post(TAUTULLI_URL.rstrip('/') + '/api/v2', params=payload)
        response = req.json()

        if response['response']['result'] == 'success':
            sys.stdout.write(
                "Successfully killed Plex session: {0}.\n".format(session_id))
            if notifier:
                if username:
                    body = BODY_TEXT_USER.format(user=username,
                                                 message=message)
                else:
                    body = BODY_TEXT.format(id=session_id, message=message)
                send_notification(SUBJECT_TEXT, body, notifier)
        else:
            raise Exception(response['response']['message'])
    except Exception as e:
        sys.stderr.write(
            "Tautulli API 'terminate_session' request failed: {0}.".format(e))
        return None

def arg_decoding(arg):

    return arg.decode(TAUTULLI_ENCODING).encode('UTF-8')

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Limiting Plex users by plays, watches, or total time from Tautulli.")
    parser.add_argument('--jbop', required=True, choices=SELECTOR,
                        help='Limit selector.\nChoices: (%(choices)s)')
    parser.add_argument('--username', required=True,
                        help='The username of the person streaming.')
    parser.add_argument('--sessionId', required=True,
                        help='The unique identifier for the stream.')
    parser.add_argument('--notify', type=int,
                        help='Notification Agent ID number to Agent to send '
                             'notification.')
    parser.add_argument('--limit', action='append', type=lambda kv: kv.split("="),
                        help='The limit related to the limit selector chosen.')
    parser.add_argument('--grandparent_rating_key', type=int,
                        help='The unique identifier for the TV show or artist.')
    parser.add_argument('--delay', type=int, default=60,
                        help='The seconds to wait in order to deem user is active.')
    parser.add_argument('--killMessage', nargs='+',
                        help='Message to send to user whose stream is killed.')
    parser.add_argument('--section', default=False, choices=lib_dict.keys(), metavar='',
                        help='Space separated list of case sensitive names to process. Allowed names are: \n'
                             '(choices: %(choices)s)')
    parser.add_argument('--days', type=int, default=0, nargs='?',
                        help='Search history limit. \n'
                             'Default: %(default)s day(s) (today).')
    parser.add_argument('--duration', type=int, default=0,
                        help='Duration of item that triggered script agent.')
    parser.add_argument('--sleep_hours', type=float, default=0,
                        help='Hours to wait after the episode number <limit> before asking if user is sleeping.')

    opts = parser.parse_args()

    history_lst = []
    total_limit = 0
    total_jbop = 0
    duration = 0
    dates = []
    delta = timedelta(days=opts.days)

    for i in range(delta.days + 1):
        day = TODAY + timedelta(days=-i)
        dates.append(day.strftime('%Y-%m-%d'))

    if opts.limit:
        limit = dict(opts.limit)

        for key, value in limit.items():
            if key == 'days':
                total_limit += int(value) * (24 * 60 * 60)
            elif key == 'hours':
                total_limit += int(value) * (60 * 60)
            elif key == 'minutes':
                total_limit += int(value) * 60
            elif key == 'plays':
                total_limit = int(value)

    if not opts.sessionId:
        sys.stderr.write("No sessionId provided! Is this synced content?\n")
        sys.exit(1)

    if opts.duration:
        # If duration is used convert to seconds from minutes
        duration = opts.duration * 60

    if opts.killMessage:
        message = ' '.join(opts.killMessage)
    else:
        message = ''

    for date in dates:
        if opts.section:
            section_id = lib_dict[opts.section]
            history = get_history(username=opts.username, section_id=section_id, start_date=date)
        else:
            history = get_history(username=opts.username, start_date=date)
        history_lst.append(history)

    if opts.jbop == 'watch':
        total_jbop = sum([data['watched_status'] for history in history_lst for data in history['data']])
    if opts.jbop == 'time':
        total_jbop = sum([data['duration'] for history in history_lst for data in history['data']])
    if opts.jbop == 'plays':
        total_jbop = sum([history['recordsFiltered'] for history in history_lst])

    if total_jbop:
        if total_jbop > total_limit:
            print('Total {} ({}) is greater than limit ({}).'
                  .format(opts.jbop, total_jbop, total_limit))
            terminate_session(opts.sessionId, message, opts.notify, opts.username)
        elif (duration + total_jbop) > total_limit:
            interval = 60
            start = 0
            while (start + total_jbop) < total_limit:
                if get_activity(opts.sessionId):
                    sleep(interval)
                    start += interval
                else:
                    print('Session; {} has been dropped. Stopping monitoring of stream.'.format(opts.sessionId))
                    exit()

            print('Total {} ({} + current item duration {}) is greater than limit ({}).'
                  .format(opts.jbop, total_jbop, duration, total_limit))
            terminate_session(opts.sessionId, message, opts.notify, opts.username)
        else:
            if duration:
                print('Total {} ({} + current item duration {}) is less than limit ({}).'
                      .format(opts.jbop, total_jbop, duration, total_limit))
            else:
                print('Total {} ({}) is less than limit ({}).'
                      .format(opts.jbop, total_jbop, total_limit))
    # todo-me need more flexibility for pulling history
    # limit work requires gp_rating_key only? Needs more options.
    if opts.jbop == 'limit' and opts.grandparent_rating_key:
        ep_watched = []
        stopped_time = []
        for date in dates:
            history_lst.append(get_history(username=opts.username, start_date=date))
        # If message is not already defined use default message
        if not message:
            message = LIMIT_MESSAGE.format(delay=opts.delay)
        for history in history_lst:
            ep_watched += [data['watched_status'] for data in history['data']
                          if data['grandparent_rating_key'] == opts.grandparent_rating_key and
                          data['watched_status'] == 1]

            stopped_time += [data['stopped'] for data in history['data']
                            if data['grandparent_rating_key'] == opts.grandparent_rating_key and
                            data['watched_status'] == 1]

        # If show has no history for date range start at 0.
        if not ep_watched:
            ep_watched = 0
        else:
            ep_watched = sum(ep_watched)

        # If show episode have not been stopped (completed?) then use current time.
        # Last stopped time is needed to test against auto play timer
        if not stopped_time:
            stopped_time = unix_time
        else:
            stopped_time = stopped_time[0]

        if '@' in opts.username:
            filename = f"{opts.username.split('@')[0]}_last_time.pickle"            # if username is an email get only the name before the '@'
        else:
            filename = f"{opts.username}_last_time.pickle"

        if abs(stopped_time - unix_time) > opts.delay:
            print('{} is awake!'.format(opts.username))
            sys.exit(1)

        # with open(filename, 'wb') as handle:
        #     pickle.dump(int(ttime()), handle, protocol=pickle.HIGHEST_PROTOCOL)

        if ep_watched >= total_limit:
            try:
                with open(filename, 'rb') as handle:                                    # after the limit has been reached get time variable from pickle file
                    time_old = pickle.load(handle)
            except:
                time_old = 0

            if int(ttime()) - time_old > opts.sleep_hours*60*60:                    # check if more than 1.5 hours have passed
                print("{}'s limit is {} and has watched {} episodes of this show.".format(opts.username, total_limit, ep_watched))
                with open(filename, 'wb') as handle:
                    pickle.dump(int(ttime()), handle, protocol=pickle.HIGHEST_PROTOCOL)
                terminate_session(opts.sessionId, message, opts.notify, opts.username)
        else:
            print("{}'s limit is {} but has only watched {} episodes of this show.".format(opts.username, total_limit, ep_watched))

[blacktwin]

You need to pull the latest master/main and create a PR for the changes you want me to approve. I have no idea what you're trying to add.