Tvheadend

#!/usr/bin/env python

# coding=utf-8

#

# Copyright (C) 2012 Adam Sutton <[email protected]>

# Modified Feb 2015 by ulibuck to generate xmltv data

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, version 3 of the License.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

"""

Connect to a HTSP server and generate xmltv data -- channels and epg entries -- from asynchronous initialSync

"""

# System imports

import os, sys, pprint, time

from optparse import OptionParser

from operator import itemgetter, attrgetter

# TVH imports

from tvh.htsp import HTSPClient

import tvh.log as log

# encode xml escape characters

def encodeXMLText(text):

  text = text.replace("&", "&")

  text = text.replace("\"", """)

  text = text.replace("'", "'")

  text = text.replace("<", "&lt;")

  text = text.replace(">", ">")

  return text

# define EPG genre names

def genre_names ( mcat, scat ):

  epg_genre_names = [

  [ "Undefined content" ],

  [ "Movie / Drama",

    "Detective / Thriller",

    "Adventure / Western / War",

    "Science fiction / Fantasy / Horror",

    "Comedy",

    "Soap / Melodrama / Folkloric",

    "Romance",

    "Serious / Classical / Religious / Historical movie / Drama",

    "Adult movie / Drama" ],

  [ "News / Current affairs",

    "News / Weather report",

    "News magazine",

    "Documentary",

    "Discussion / Interview / Debate" ],

  [ "Show / Game show",

    "Game show / Quiz / Contest",

    "Variety show",

    "Talk show" ],

  [ "Sports",

    "Special events (Olympic Games, World Cup, etc.)",

    "Sports magazines",

    "Football / Soccer",

    "Tennis / Squash",

    "Team sports (excluding football)",

    "Athletics",

    "Motor sport",

    "Water sport",

    "Winter sports",

    "Equestrian",

    "Martial sports" ],

  [ "Children's / Youth programmes",

    "Pre-school children's programmes",

    "Entertainment programmes for 6 to 14",

    "Entertainment programmes for 10 to 16",

    "Informational / Educational / School programmes",

    "Cartoons / Puppets" ],

  [ "Music / Ballet / Dance",

    "Rock / Pop",

    "Serious music / Classical music",

    "Folk / Traditional music",

    "Jazz",

    "Musical / Opera",

    "Ballet" ],

  [ "Arts / Culture (without music)",

    "Performing arts",

    "Fine arts",

    "Religion",

    "Popular culture / Traditional arts",

    "Literature",

    "Film / Cinema",

    "Experimental film / Video",

    "Broadcasting / Press",

    "New media",

    "Arts / culture magazines",

    "Fashion" ],

  [ "Social / Political issues / Economics",

    "Magazines / Reports / Documentary",

    "Economics / Social advisory",

    "Remarkable people" ],

  [ "Education / Science / Factual topics",

    "Nature / Animals / Environment",

    "Technology / Natural sciences",

    "Medicine / Physiology / Psychology",

    "Foreign countries / Expeditions",

    "Social / Spiritual sciences",

    "Further education",

    "Languages" ],

  [ "Leisure hobbies",

    "Tourism / Travel",

    "Handicraft",

    "Motoring",

    "Fitness and health",

    "Cooking",

    "Advertisement / Shopping",

    "Gardening" ]

  ]

  if len(epg_genre_names) <= mcat : mcat = 0

  if len(epg_genre_names[mcat]) <= scat: scat = 0

  return epg_genre_names[mcat][scat]

# Formatiere Datum und Uhrzeit für die Ausgabe

def datumzeit (Zeit):

  Wochentage = ["Mo","Di","Mi","Do","Fr","Sa","So"]

  Monatsnamen = ["Jan","Feb","Mrz","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"]

  Wochentag = Wochentage[Zeit.tm_wday]

  Monatstag = Zeit.tm_mday

  Monat = Monatsnamen [Zeit.tm_mon-1]

  return '%s %02d %s %s' % (Wochentag, Monatstag, Monat, time.strftime('%Y %H:%M:%S',Zeit))

try:

  # Command line

  optp = OptionParser()

  optp.add_option('-a', '--host', default='localhost',

                  help='Specify HTSP server hostname [localhost]')

  optp.add_option('-o', '--port', default=9982, type='int',

                  help='Specify HTSP server port [9982]')

  optp.add_option('-u', '--user', default=None,

                  help='Specify HTSP authentication username [None]')

  optp.add_option('-p', '--passwd', default=None,

                  help='Specify HTSP authentication password [None]')

  optp.add_option('-e', '--epg', default=True, action='store_false',

                  help='Exclude EPG data [Include]')

  optp.add_option('-t', '--update', default=None, type='int',

                  help='Specify when to receive updates from [None]')

  xnam = '%s.xml' % (os.path.splitext(__file__)[0])

  optp.add_option('-x', '--xnam', default=None,

                  help='Specify xml output file name [%s]' % (xnam))

  (opts, args) = optp.parse_args()

  # Connect

  htsp = HTSPClient((opts.host, opts.port))

  msg  = htsp.hello()

  sernam = msg['servername']

  server = msg['serverversion']

  log.info('%s connected to [%s] / %s [%s] / HTSP v%d' % (htsp._name, opts.host, sernam, server, htsp._version))

  # Authenticate

  if opts.user:

    htsp.authenticate(opts.user, opts.passwd)

    log.info('authenticated as %s' % opts.user)

  # Enable async

  args = {}

  if opts.epg:

    args['epg']   = 1

  if opts.update != None:

    args['lastUpdate'] = opts.update

  htsp.enableAsyncMetadata(args)

  # log.info('generating xmltv -- channels and epg entries -- from asynchronous initialSync')

  # Process messages

  chanNum={}

  chanAdd=[]

  evenAdd=[]

  while True:

    msg = htsp.recv()

    if 'method' in msg:

      if msg['method'] == 'channelAdd':

        chanNum[msg['channelId']]=msg['channelNumber']

        chanAdd.append(msg)    # store 'channelAdd' message

      elif msg['method'] == 'eventAdd':

        msg['channelNumber']=chanNum[msg['channelId']]

        evenAdd.append(msg)    # store 'eventAdd' message

      elif msg['method'] == 'initialSyncCompleted':

        break

  # log.info('initialSync completed -- %d channels and %d events' % (len(chanAdd), len(evenAdd)))

  # determine the local time offset to UTC

  etm = int(time.time())    # seconds since the epoch

  nlc = time.localtime(etm)    # convert to struct_time in local time

  ngm = time.gmtime(etm)    # convert to struct_time in UTC

  # convert back to seconds since the epoch

  # - interpret struct_time in UTC in local time using mktime()

  # - use daylight savings flag from local time

  egm = time.mktime((ngm[0],ngm[1],ngm[2],ngm[3],ngm[4],ngm[5],ngm[6],ngm[7],nlc[8]))

  edf = etm - egm    # local time offset to UTC in seconds = difference of the two times 

  sdf = 1

  if edf < 0: sdf = -1    # sign of the time difference

  hrh = int(sdf*edf/36)    # time difference in hours times hundred

  mts = int((hrh%100)*3/5)    # convert fraction of hour to minutes

  hrmt = '%+05d' % (sdf*(int(hrh/100)*100 + mts))    # UTC offset in the form +HHMM or -HHMM

  # generate xmltv

  if opts.xnam != None:

    xnam = opts.xnam

  file = open (xnam, 'w')

  gnam = os.path.basename(__file__)

  file.write('<?xml version="1.0" encoding="UTF-8"?>\n')

  file.write('<!DOCTYPE tv SYSTEM "xmltv.dtd">\n')

  out = '<tv date="%s %s" source-info-name="%s [%s]" generator-info-name="%s">\n' \

        % (time.strftime('%Y%m%d%H%M%S'), hrmt, sernam, server, gnam)

  file.write(out)

  chanAddSorted = sorted(chanAdd, key=itemgetter('channelNumber'))

  for msg in chanAddSorted:

    out = '  <channel id="%s">\n' % (msg['channelNumber'])

    file.write(out)

    out = '    <display-name>%s</display-name>\n' % (encodeXMLText(msg['channelName']))

    file.write(out)

    if 'channelIcon' in msg:

      out = '    <icon src="%s"/>\n' % (msg['channelIcon'])

      file.write(out)

    out = '  </channel>\n'

    file.write(out)

  evenAddSorted = sorted(evenAdd, key=itemgetter('channelNumber', 'start'))

  for msg in evenAddSorted:

    sta = time.localtime(msg['start'])

    sto = time.localtime(msg['stop'])

    out = '  <programme channel="%s" start="%s %s" stop="%s %s">\n' \

          % (msg['channelNumber'], time.strftime('%Y%m%d%H%M%S',sta), hrmt, time.strftime('%Y%m%d%H%M%S',sto), hrmt)

    file.write(out)

    if 'title' in msg:

      out = '    <title>%s</title>\n' % (encodeXMLText(msg['title']))

    else:

      out = '    <title>no title</title>\n'

    file.write(out)

    if 'description' in msg:

      out = '    <desc>%s</desc>\n' % (encodeXMLText(msg['description']))

      file.write(out)

    if 'summary' in msg:

      out = '    <sub-title>%s</sub-title>\n' % (encodeXMLText(msg['summary']))

      file.write(out)

    if 'contentType' in msg:

      bits = '{0:08b}'.format(msg['contentType'])

      mcat = int(bits[:4],2)    # top 4 bits has major category

      scat = int(bits[4:],2)    # bottom 4 bits has sub-category

      out = '    <category>%s</category>\n' % (encodeXMLText(genre_names(mcat,scat)))

      file.write(out)

    out = '  </programme>\n'

    file.write(out)

  out = '</tv>\n'

  file.write(out)

  file.close()

  now = time.localtime()

  sys.stdout.write('%s  %s -- %d channels and %d epg entries\n' % (datumzeit(now), xnam, len(chanAdd), len(evenAdd)))

except KeyboardInterrupt: pass

except Exception, e:

  log.error(e)

  sys.exit(1) 

# ############################################################################

# Editor Configuration

#

# vim:sts=2:ts=2:sw=2:et

# ############################################################################