Note: Starting with v31, Python version 3 is supported. Adjust references to the host's Python version below as required.

#!/usr/bin/python3
from MythTV.services_api import send as api

BACKEND = api.Send(host='localhost')
resultDict = BACKEND.send(endpoint='Myth/GetHostName')

print 'Entire response:', resultDict
print 'Backend hostname (MythTV profile name) is: ', resultDict['String']

#!/usr/bin/python3
from MythTV.services_api import send as api

BACKEND = api.Send(host='localhost')
r = BACKEND.send(endpoint='Myth/GetTimeZone')

print r
print r['TimeZoneInfo']
print r['TimeZoneInfo']['TimeZoneID']
print r['TimeZoneInfo']['UTCOffset']
print r['TimeZoneInfo']['CurrentDateTime']

#!/usr/bin/python3

import os.path as path
import sys
from MythTV.services_api import send as api

try:
    BEHOST = sys.argv[1]
    DBHOST = sys.argv[2]
    DBUSER = sys.argv[3]
    DBPSWD = sys.argv[4]
except IndexError:
    sys.exit('\nUsage: {} backend_host db_host db_user db_password'
             .format(path.basename(sys.argv[0])))

POSTDATA = {'HostName': DBHOST, 'UserName': DBUSER, 'Password': DBPSWD}

BACKEND = api.Send(host=BEHOST)
r = BACKEND.send(endpoint='Myth/TestDBSettings',
             postdata=POSTDATA, opts={'debug': True, 'wrmi': True})

print r

#!/usr/bin/python3
# -*- coding: utf-8 -*-                                                         
                                                                                
"""Print Start Times, Titles and SubTitles"""                                   
                                                                                
from __future__ import print_function                                           
import sys                                                                      
from MythTV.services_api import send as api                                     
                                                                                
                                                                                
def main():                                                                     
    """Check host, request upcomings and print"""                               
                                                                                
    try:                                                                        
        host = sys.argv[1]                                                      
    except IndexError:                                                          
        host = 'localhost'                                                      
                                                                                
    backend = api.Send(host=host)                                               
                                                                                
    try:                                                                        
        resp_dict = backend.send(endpoint='Dvr/GetUpcomingList')                
    except RuntimeError as error:                                               
        sys.exit('\nFatal error: "{}"'.format(error))                           
                                                                                
    count = int(resp_dict['ProgramList']['Count'])                              
    progs = resp_dict['ProgramList']['Programs']                                
                                                                                
    if count < 1:                                                               
        sys.exit('\nNo upcoming recordings found.\n')                           
                                                                                
    for upcoming in range(count):                                               
        print('  {}  {:45.45}  {:15.15}'.format(                                
            progs[upcoming]['Recording']['StartTs'],                            
            progs[upcoming]['Title'],                                           
            progs[upcoming]['SubTitle']))                                       
                                                                                
                                                                                
if __name__ == '__main__':                                                      
    main()                                                                      
                                                                                
# vim: set expandtab tabstop=4 shiftwidth=4 smartindent noai colorcolumn=80:

!/usr/bin/python3
# -*- coding: utf-8 -*-

'''
Print Start Times, Titles and SubTitles.

Optionally filter by Titles/ChanId or limited by days. Optionally print
the cast members for each recording. This is an 'overly-commented', and
simple example of using the Services API to do a task. It also forms a
template for working with the API.

Good Start:          print_upcoming.py --help
Watch what it sends: print_upcoming.py --host=Name/IP --debug
'''

from __future__ import print_function
from datetime import datetime
import argparse
import logging
import re
import sys
import time
from MythTV.services_api import send as api
from MythTV.services_api import utilities as util

DAY_IN_SECONDS = 24 * 60 * 60
TIME_NOW = time.mktime(datetime.now().timetuple())
WHITE = '\033[0m'
YELLOW = '\033[93m'


def flags_to_strings(flgs):
    '''
    Convert the decimal flags to a printable string. From:
    libs/libmyth/programtypes.h. The </> print for values that
    haven't been defined here yet (and maybe should be.)
    '''
    strlst = list()
    if flgs & (0x00fff):
        strlst.append('<')
    if flgs & (1 << 12):
        strlst.append('Rerun')
    if flgs & (1 << 13):
        strlst.append('Dup')
    if flgs & (1 << 14):
        strlst.append('React')
    if flgs & (0xf8000):
        strlst.append('>')
    return ', '.join(strlst)


def process_command_line():
    '''
    Add command arguments, as required, here. --host is likely
    a minimum and mandatory unless it has a default value below.
    Examples include string, integer and bool type arguments.
    Printing the default values is also shown.
    '''

    parser = argparse.ArgumentParser(description='Print Upcoming Programs',
                                     epilog='Default values are in ()s')

    parser.add_argument('--cast', action='store_true',
                        help='include cast member names (%(default)s)')

    parser.add_argument('--chanid', type=int, required=False,
                        metavar='<chanid>',
                        help='filter on MythTV chanid, e.g. 1091 (none).')

    parser.add_argument('--days', type=int, required=False, metavar='<days>',
                        default=7,
                        help='days of programs to print (%(default)s)')

    parser.add_argument('--debug', action='store_true',
                        help='turn on debug messages (%(default)s)')

    parser.add_argument('--digest', type=str, metavar='<user:pass>',
                        help='digest username:password')

    parser.add_argument('--host', type=str, required=False,
                        default='localhost',
                        metavar='<hostname>',
                        help='backend hostname (%(default)s)')

    parser.add_argument('--port', type=int, default=6544, metavar='<port>',
                        help='port number of the Services API (%(default)s)')

    parser.add_argument('--showall', action='store_true',
                        help='include conflicts etc. (%(default)s)')

    parser.add_argument('--title', type=str, default='', required=False,
                        metavar='<title>', help='filter by title (none)')

    parser.add_argument('--version', action='version', version='%(prog)s 0.10')

    return parser.parse_args()


def print_details(program, args):
    '''
    Print a single program's information. Apply the --title and --chanid
    filters to select limited sets of recordings. Exit False if the
    --days limit is reached.
    '''

    title = program['Title']
    subtitle = program['SubTitle']
    flags = int(program['ProgramFlags'])
    chanid = int(program['Channel']['ChanId'])
    startts = util.utc_to_local(program['Recording']['StartTs'])
    # status = int(program['Recording']['Status'])
    start_time = time.mktime(datetime.strptime(startts, "%Y-%m-%d %H:%M")
                             .timetuple())

    if int((start_time - TIME_NOW) / DAY_IN_SECONDS) >= args.days:
        return -1

    if (args.title is None or re.search(args.title, title, re.IGNORECASE)) \
            and (args.chanid is None or args.chanid == chanid):

        print(u'  {:16.16}  {:40.40}  {:25.25}  {}'
              .format(startts, title, subtitle,
                      flags_to_strings(flags)).encode('utf-8'))

        if args.cast:
            cast = program['Cast']['CastMembers']
            for i in range(100):
                try:
                    print(u'\t{} ({})'.format(cast[i]['Name'],
                                              cast[i]['TranslatedRole'])
                          .encode('utf-8'))
                except IndexError:
                    break

        return 1

    return 0


def main():
    '''
    Get the upcoming recordings from the backend and process them
    based on the filters and number of days of interest.
    '''

    args = process_command_line()
    opts = dict()

    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
    logging.getLogger('requests.packages.urllib3').setLevel(logging.WARNING)
    logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)

    try:
        opts['user'], opts['pass'] = args.digest.split(':')
    except (AttributeError, ValueError):
        pass

    ##############################################################
    # Request the upcoming list from the backend and check the   #
    # response ...                                               #
    ##############################################################

    endpoint = 'Dvr/GetUpcomingList'

    if args.showall:
        rest = 'ShowAll=true'
    else:
        rest = ''

    backend = api.Send(host=args.host)

    try:
        resp_dict = backend.send(endpoint=endpoint, rest=rest, opts=opts)
    except RuntimeError as error:
        sys.exit('\nFatal error: "{}"'.format(error))

    ##############################################################
    # ... and also set the module's timezone offset so that the  #
    # start times in the response can be converted to local time.#
    ##############################################################

    util.get_utc_offset(backend=backend, opts=opts)

    count = int(resp_dict['ProgramList']['TotalAvailable'])
    programs = resp_dict['ProgramList']['Programs']

    if args.debug:
        print('Debug: Upcoming recording count = {}'.format(count))

    if count < 1:
        print('\nNo upcoming recordings found.\n')
        sys.exit(0)

    print('\nPrinting {} day{} of upcoming programs sorted by StartTime'
          .format(args.days, 's'[args.days == 1:]))
    print(u'\n  {}{:16}  {:40.40}  {:25.25}  {}  {}'
          .format(YELLOW, 'StartTime', 'Title', 'SubTitle',
                  'Flags', WHITE).encode('utf-8'))

    matched_upcoming = 0

    for program in programs:

        retval = print_details(program, args)

        if retval == -1:
            break

        matched_upcoming += retval

    print('\n  Total Upcoming Programs: {}'.format(matched_upcoming))


if __name__ == '__main__':
    main()

# vim: set expandtab tabstop=4 shiftwidth=4 smartindent colorcolumn=80: