Difference between revisions of "Python API Examples"

From MythTV Official Wiki
Jump to: navigation, search
(Update example links to v30/v31)
(Switch shebangs to /usr/bin/python3)
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
 
{{Basic Services API Access}}
 
{{Basic Services API Access}}
 
=Python Services API Cookbook=
 
=Python Services API Cookbook=
 
+
{{Note box|Starting with v31, Python version 3 is supported. Adjust references to the host's Python version below as required.}}
 +
<br/>
 
What follows are some working ''Python'' programs that use
 
What follows are some working ''Python'' programs that use
 
the MythTV [[Services API]]. If the user's language of
 
the MythTV [[Services API]]. If the user's language of
Line 82: Line 83:
  
 
===Displaying the module's help information===
 
===Displaying the module's help information===
As with any proper ''Python'' module, built-in help
+
As with any proper ''Python'' package, built-in help
 
is available. Try the following:
 
is available. Try the following:
 
<pre>
 
<pre>
$ python
+
$ python3 # or python2
 
>>> from MythTV.services_api import send as api
 
>>> from MythTV.services_api import send as api
 
</pre>
 
</pre>
Line 93: Line 94:
 
>>> control-D # After the help prints
 
>>> control-D # After the help prints
 
</pre>
 
</pre>
 +
 
==Examples==
 
==Examples==
 
Once the module is installed, the following examples will work.
 
Once the module is installed, the following examples will work.
Line 116: Line 118:
  
 
{{Python|simple_api_test.py|<pre>
 
{{Python|simple_api_test.py|<pre>
#!/usr/bin/env python
+
#!/usr/bin/python3
 
from MythTV.services_api import send as api
 
from MythTV.services_api import send as api
  
Line 144: Line 146:
  
 
{{Python|get_timezone_info.py|<pre>
 
{{Python|get_timezone_info.py|<pre>
#!/usr/bin/env python
+
#!/usr/bin/python3
 
from MythTV.services_api import send as api
 
from MythTV.services_api import send as api
  
Line 179: Line 181:
 
The expected response will end with: ''{"bool": "true"}''.  
 
The expected response will end with: ''{"bool": "true"}''.  
 
{{Python|simple_post.py|<pre>
 
{{Python|simple_post.py|<pre>
#!/usr/bin/env python
+
#!/usr/bin/python3
  
 
import os.path as path
 
import os.path as path
Line 223: Line 225:
 
used in this example.
 
used in this example.
 
{{Python|short_print_upcoming.py|<pre>
 
{{Python|short_print_upcoming.py|<pre>
#!/usr/bin/env python                                                         
+
#!/usr/bin/python3
 
# -*- coding: utf-8 -*-                                                         
 
# -*- coding: utf-8 -*-                                                         
 
                                                                                  
 
                                                                                  
Line 288: Line 290:
 
''Python'' programs.
 
''Python'' programs.
 
{{Python|print_upcoming.py|<pre>
 
{{Python|print_upcoming.py|<pre>
!/usr/bin/python2
+
!/usr/bin/python3
 
# -*- coding: utf-8 -*-
 
# -*- coding: utf-8 -*-
  

Latest revision as of 18:14, 2 February 2020


Existing sources of information

  • Local backend: e.g. http://<backendHostNameOrIP>:6544/Channel/wsdl
  • The 'old' protocol version. Use of this mechanism is discouraged but its pages are a still a good source for (say) program data. Myth Protocol
  • The the MythTV forum has a Services API section – fast and helpful responses!
  • Source code (if desperate!): For example, the Dvr service

Getting information from the backend

The backend can be read using a standard web interface and there are a number of ways of doing this..

Web browser

In its simplest form, a browser will show the data e.g.

http:/<backendHostNameOrIP>:6544/Dvr/GetRecordedList?StartIndex=2&Count=1&Descending=true

will show a single entry from the recorded list.

This is a useful development aid but note that the browser helpfully inserts newlines or tabs for readability but these will not be present if the same page is read with perl code.

Notice that empty values like <XMLTVID></XMLTVID> will display as: <XMLTV/>.

curl

From the shell, curl can do the same, e.g.

curl <backendHostNameOrIP>:6544/Dvr/GetRecordedList?StartIndex=2\&Count=1\&Descending=true | sed "s/></>\n</g"

Note the \ to prevent the shell from spinning off the command at the &. The sed inserts newlines for readability.


Python Services API Cookbook

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


What follows are some working Python programs that use the MythTV Services API. If the user's language of choice is Perl, then see: Perl API examples

Unlike Python Bindings, only basic access to the Services API is provided here. Users will need to retrieve data from the Services/endpoints of interest to them. N.B. not everything available in Python Bindings' is available in the API.

There are excellent links that list the available services and endpoints. See these: API parameters 30 and API parameters 31.

The examples depend on a module which is available in v30 and above. Users of earlier versions can install the source themselves. See: https://code.mythtv.org/cgit/mythtv/tree/mythtv/bindings/python/MythTV/services_api

This page was written and tested using 0.28-pre under python 2.7 and 3.4.

About the Module

First, it's not necessary to use it! Users can write their own code to send information to the back/frontend. The module provides a reasonable template of things that should be done. Included are checking of the arguments, some optional debugging statements, optional header choices and error handling.

The module formats a JSON response from the server into a Python dict.

Installing and importing the module

This is for users running versions below v30.

In v30+, the module is part of the Python bindings and can be imported like this from MythTV.services_api import send as api.

Where the module is installed is up to the user. The recommendation is to choose one of the following. But first, decide which host(s) the module is to be installed on. It could be a backend, but that isn't necessary. Install it on any host(s) that want to access the Services API

Install in the user's bin directory (easiest)

If the module is installed in the same directory (typically: ~/bin) as the program(s) that use it, then include a line like this in those programs:

import services_api as api

The as api is optional, but convenient. All examples in this page will assume this method.

Install elsewhere and set PYTHONPATH

Put the module somewhere other than in the existing $PATH where programs using it are located. Then set PYTHONPATH to point to that directory. For example, the following line could be added to a .profile or .bashrc file:

export PYTHONPATH=/home/services_api

Import it as in the above.

Install in a dist-packages directory (hardest/preferred)

Create a new directory below the existing MythTV directory that might be found in directories like these:

/usr/local/lib/python2.7/dist-packages/
/usr/lib/python2.7/dist-packages/
/usr/lib/python3.4/dist-packages
/usr/local/lib/python3.4/dist-packages

Create a new directory named services_api and put the __init__.py, send.py, utilities.py and _version.py file under it. Savy users will use a Makefile and setup.py program to do this (and create .pyc files etc.)

MacPorts users might find the bindings under: /opt/dvr/bin/python2.7.

Importing the module would then be done like this:

from MythTV.services_api import send as api

Displaying the module's help information

As with any proper Python package, built-in help is available. Try the following:

$ python3 # or python2
>>> from MythTV.services_api import send as api

Followed by:

>>> help(api)
>>> control-D # After the help prints

Examples

Once the module is installed, the following examples will work.

Notice that in the following, localhost is used for the host argument to Send(). That means these will be run on a MythTV backend. But that isn't required. The module and examples can be put on any host that has access to the backend and run from there. Just replace host= 'localhost' with host= <backendHostNameOrIpAddress>.

Myth/GetHostName endpoint example

Getting the backend's hostname returns the simplest response in the API. It's the easiest to parse and has the hostname of the backend (really, it's the profile name used in the DB and honors the LocalHostName line in config.xml, but that's another Wiki.) It's a great place to start learning about the API.

Put the following in a file, perhaps simple_api_test.py. Make it executable and run it. Adjust the #! line as required. For example, MacPorts users might replace the 1st line below with #!/opt/dvr/bin/python2.7


PythonIcon.png simple_api_test.py
#!/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']

As mentioned above as api is optional. Calling send.Send(...) is also valid. There's nothing special about resultDict other than it reminds the user that the results are being returned in a Python dict format.

Look at the two lines of output. The 1st is the complete response, a simple dictionary with one element, the key String contains the value someHostName. This is important as later examples will be more complex dictionaries.

Entire response: {u'String': u'backendHostName'}
Backend hostname (MythTV profile name) is: someBackendHostName

The Myth/GetTimeZone endpoint example

A slightly more complex example:


PythonIcon.png get_timezone_info.py
#!/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']

The GetTimeZone JSON response contains a dictionary (TimeZoneInfo) with dictionary inside it that has three keys. Expect to see something like this:

{u'TimeZoneInfo': {u'TimeZoneID': u'America/Chicago', u'UTCOffset': u'-21600', u'CurrentDateTime': u'2015-11-13T19:26:18Z'}}
{u'TimeZoneID': u'America/Chicago', u'UTCOffset': u'-21600', u'CurrentDateTime': u'2015-11-13T19:26:18Z'}}
America/Chicago
-21600
2015-11-13T19:26:18Z

Myth/TestDBSettings (POST Example)

Take note that some endpoints require an HTTP POST (as opposed to the default GET.) This is detailed in the Wikis for each service. Anything that changes data must use a POST and the following is another example.

Try the following. Remember, backend_host and db_host are frequently the same, but can be different.

In opts, wrmi (We Really Mean It) must be True. Try setting it to False and see the result (it's good for debugging before an endpoint that changes data is used.)

The expected response will end with: {"bool": "true"}.

PythonIcon.png simple_post.py
#!/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

Working program using the Dvr/GetUpcomingList endpoint

Here's a simple program, with a bit of formatting, that does a practical task. Refer to the tools in the beginning of this page to see the XML output of this endpoint. Viewing it with a browser may make the dicts easier to understand.

Put the following in a file, like: short_print_upcoming.py and type: short_print_upcoming.py backendHostNameOrIPaddress

Note the line: progs = resp_dict['ProgramList']['Programs'] below. Rather than referencing each upcoming program as: resp_dict['ProgramList']['Programs'][upcoming], they can be examined as: progs[upcoming].... upcoming here is the index into a list contained in the Programs key.

Also note that there's yet another dict under progs, it's the ['Recording'] dict where only the StartTs is used in this example.

PythonIcon.png short_print_upcoming.py
#!/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:

To see the way the response is returned, try adding lines like these to the end of the program:

print resp_dict
print resp_dict['ProgramList']['Programs'][0]
print progs[0]

The 1st displays the entire response in a dictionary, the 2nd just the 0th program returned and the last is the same as the 2nd.

Full example using Dvr/GetUpcomingList

Using the ideas above, the following is a complete program with command line arguments used to set some of the opts values, and set a variable host etc. Type: ./print_upcoming.py --help for details. Try the --debug argument to see the URLs generated by the program.

The concepts here can serve as a guide to creating your own Python programs.

PythonIcon.png print_upcoming.py
!/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:

By getting the time zone information from the backend, each start time in the output is converted to local time rather than the UTC returned by the Services API. Another note about the above is the use of print(u'....) followed by .encode('utf-8). That's critical for Titles/SubTitles for example where there are characters like: ó. In Python3, this isn't requried.