def __init__(self,configLocation="./zap2itconfig.ini",outputFile="xmlguide.xmltv"):

self.confLocation = configLocation

self.outputFile=outputFile

if not os.path.exists(self.confLocation):

print("Error: " + self.confLocation + " does not exist.")

print("Copy config.ini.dist to config.ini and update the settings to match your zap2it account")

exit(1)

print("Loading config: ", self.confLocation, " and outputting: ", outputFile)

self.config = configparser.ConfigParser()

config = self.config.read(self.confLocation)

if config == []:

print("Failed to read config: " + self.confLocation)

print("Check file permissions")

exit(1)

# Use get_config_value for all config lookups

self.lang = self.get_config_value("prefs","lang", fallback="en")

self.zapToken = ""

def get_config_value(self, section, key, fallback=None):

# Environment variable name: ZAP2IT_SECTION_KEY

env_var = f"ZAP2IT_{section.upper()}_{key.upper()}"

#print(f"Checking for environment variable: {env_var}")

if env_var in os.environ:

#print(f"Using environment variable {env_var} for {section}.{key}")

return os.environ[env_var]

#print(f"Using config.ini value for {section}.{key}")

return self.config.get(section, key, fallback=fallback)

def BuildAuthRequest(self):

url = "https://tvlistings.gracenote.com/api/user/login"

parameters = {

"emailid": self.get_config_value("creds","username"),

"password": self.get_config_value("creds","password"),

"isfacebookuser": "false",

"usertype": 0,

"objectid": ""

}

data = urllib.parse.urlencode((parameters))

data = data.encode('ascii')

req = urllib.request.Request(url, data, headers={'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'})

return req

def Authenticate(self):

#Get token from login form

authRequest = self.BuildAuthRequest()

try:

authResponse = urllib.request.urlopen(authRequest, context=ssl_context).read()

except urllib.error.URLError as e:

print("Error connecting to tvlistings.gracenote.com")

print(e.reason)

exit(1)

authFormVars = json.loads(authResponse)

self.zapTocken = authFormVars["token"]

self.headendid= authFormVars["properties"]["2004"]

def BuildIDRequest(self,zipCode):

url = "https://tvlistings.gracenote.com/gapzap_webapi/api/Providers/getPostalCodeProviders/"

url += self.get_config_value("prefs","country", fallback="us") + "/"

url += zipCode + "/gapzap/"

lang = self.get_config_value("prefs","lang", fallback="en-us")

if lang != "":

url += lang

req = urllib.request.Request(url, data=None, headers={'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'})

return req

def FindID(self,zipCode):

idRequest = self.BuildIDRequest(zipCode)

try:

print("Loading provider ID data from: ",idRequest.full_url)

idResponse = urllib.request.urlopen(idRequest, context=ssl_context).read()

except urllib.error.URLError as e:

print("Error loading provider IDs:")

print(e.reason)

exit(1)

idVars = json.loads(idResponse)

print(f'{"type":<15}|{"name":<40}|{"location":<15}|',end='')

print(f'{"headendID":<15}|{"lineupId":<25}|{"device":<15}')

for provider in idVars["Providers"]:

print(f'{provider["type"]:<15}|',end='')

print(f'{provider["name"]:<40}|',end='')

print(f'{provider["location"]:<15}|',end='')

print(f'{provider["headendId"]:<15}|',end='')

print(f'{provider["lineupId"]:<25}|',end='')

print(f'{provider["device"]:<15}')

def BuildDataRequest(self,currentTime,zipCode):

#Defaults

lineupId = self.get_config_value("lineup","lineupId", fallback=self.headendid)

headendId = self.get_config_value("lineup","headendId", 'lineupId')

device = self.get_config_value("lineup","device", fallback='-')

parameters = {

'Activity_ID': 1,

'FromPage': "TV%20Guide",

'AffiliateId': "orbebb",

'token': self.zapToken,

'aid': 'orbebb',

'lineupId': lineupId,

'timespan': 3,

'headendId': headendId,

'country': self.get_config_value("prefs", "country"),

'device': device,

'postalCode': zipCode,

'isOverride': "true",

'time': currentTime,

'pref': 'm,p',

'userId': '-'

}

data = urllib.parse.urlencode(parameters)

url = "https://tvlistings.gracenote.com/api/grid?" + data

req = urllib.request.Request(url, data=None, headers={'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'})

return req

def GetData(self,time,zipCode):

print("Building data for {time} :: {zipCode}")

request = self.BuildDataRequest(time,zipCode)

print("Load Guide for time: ",str(time)," :: ",zipCode)

#print(request.full_url)

response = urllib.request.urlopen(request, context=ssl_context).read()

return json.loads(response)

def AddChannelsToGuide(self, json):

global ADDED_CHANNELS

favoriteChannels = ""

try:

favoriteChannels = self.get_config_value("prefs","favoriteChannels", fallback="")

except:

pass

for channel in json["channels"]:

if favoriteChannels != "":

if channel["channelId"] not in favoriteChannels:

continue

if channel["channelId"] in ADDED_CHANNELS:

print("Duplicate Channel: ",channel["channelId"])

continue

else:

self.rootEl.appendChild(self.BuildChannelXML(channel))

ADDED_CHANNELS.append(channel["channelId"])

def AddEventsToGuide(self,json):

dedup_count = 0

global ADDED_EVENTS

favoriteChannels = ""

try:

favoriteChannels = self.get_config_value("prefs","favoriteChannels", fallback="")

if favoriteChannels == "":

print("No favorite channels set, all channels will be included.")

raise ValueError("No favorite channels set") #TODO: Pretty dirty

except:

pass

for channel in json["channels"]:

if favoriteChannels != "":

if channel["channelId"] not in favoriteChannels:

continue

for event in channel["events"]:

#Deduplicate json

eventHash = hash(channel.get("channelId") + event.get("startTime") + event.get("endTime"))

if eventHash not in ADDED_EVENTS:

newChild = self.BuildEventXmL(event,channel["channelId"])

self.rootEl.appendChild(newChild)

ADDED_EVENTS.append(eventHash)

def BuildEventXmL(self,event,channelId):

#preConfig

season = "0"

episode = "0"

programEl = self.guideXML.createElement("programme")

programEl.setAttribute("start",self.BuildXMLDate(event["startTime"]))

programEl.setAttribute("stop",self.BuildXMLDate(event["endTime"]))

programEl.setAttribute("channel",channelId)

titleEl = self.guideXML.createElement("title")

titleEl.setAttribute("lang",self.lang) #TODO: define

titleTextEl = self.guideXML.createTextNode(event["program"]["title"])

titleEl.appendChild(titleTextEl)

programEl.appendChild(titleEl)

if event["program"]["episodeTitle"] is not None:

subTitleEl = self.CreateElementWithData("sub-title",event["program"]["episodeTitle"])

subTitleEl.setAttribute("lang",self.lang)

programEl.appendChild(subTitleEl)

if event["program"]["shortDesc"] is None:

event["program"]["shortDesc"] = "Unavailable"

descriptionEl = self.CreateElementWithData("desc",event["program"]["shortDesc"])

descriptionEl.setAttribute("lang",self.lang)

programEl.appendChild(descriptionEl)

lengthEl = self.CreateElementWithData("length",event["duration"])

lengthEl.setAttribute("units","minutes")

programEl.appendChild(lengthEl)

if event["thumbnail"]:

thumbnailUrl = "https://zpmc.tmsimg.com/assets/" + event["thumbnail"] + ".jpg?w=165"

thumbnailEl = self.CreateElementWithData("thumbnail", thumbnailUrl)

programEl.appendChild(thumbnailEl)

iconEl = self.guideXML.createElement("icon")

iconEl.setAttribute("src", thumbnailUrl)

programEl.appendChild(iconEl)

urlEl = self.CreateElementWithData("url","https://tvlistings.gracenote.com//overview.html?programSeriesId=" + event["seriesId"] + "&amp;tmsId=" + event["program"]["id"])

programEl.appendChild(urlEl)

#Build Season Data

try:

if event["program"]["season"] is not None:

season = str(event["program"]["season"])

if event["program"]["episode"] is not None:

episode = str(event["program"]["episode"])

except KeyError:

print("No Season for:" + event["program"]["title"])

for category in event["filter"]:

categoryEl = self.CreateElementWithData("category",category.replace('filter-',''))

categoryEl.setAttribute("lang",self.lang)

programEl.appendChild(categoryEl)

if(int(episode) != 0):

categoryEl = self.CreateElementWithData("category","Series")

programEl.appendChild(categoryEl)

#episodeNum = "S" + str(event["seriesId"]).zfill(2) + "E" + str(episode.zfill(2))

episodeNum = "S" + str(season).zfill(2) + "E" + str(episode.zfill(2))

episodeNumEl = self.CreateElementWithData("episode-num",episodeNum)

episodeNumEl.setAttribute("system","common")

programEl.appendChild(episodeNumEl)

seasonStr = ""

if(int(season) != 0):

seasonStr = str(int(season)-1)

episodeNum = seasonStr + "." +str(int(episode)-1)

episodeNumEl = self.CreateElementWithData("episode-num",episodeNum)

episodeNumEl.setAttribute("system", "xmltv_ns")

programEl.appendChild(episodeNumEl)

if event["program"]["id"[-4:]] == "0000":

episodeNumEl = self.CreateElementWithData("episode-num",event["seriesId"] + '.' + event["program"]["id"][-4:])

episodeNumEl.setAttribute("system","dd_progid")

else:

episodeNumEl = self.CreateElementWithData("episode-num",event["seriesId"].replace('SH','EP') + '.' + event["program"]["id"][-4:])

episodeNumEl.setAttribute("system","dd_progid")

programEl.appendChild(episodeNumEl)

#Handle Flags

for flag in event["flag"]:

if flag == "New":

programEl.appendChild(self.guideXML.createElement("New"))

if flag == "Finale":

programEl.appendChild(self.guideXML.createElement("Finale"))

if flag == "Premiere":

programEl.appendChild(self.guideXML.createElement("Premiere"))

if "New" not in event["flag"]:

programEl.appendChild(self.guideXML.createElement("previously-shown"))

for tag in event["tags"]:

if tag == "CC":

subtitlesEl = self.guideXML.createElement("subtitles")

subtitlesEl.setAttribute("type","teletext")

programEl.appendChild(subtitlesEl)

if event["rating"] is not None:

ratingEl = self.guideXML.createElement("rating")

valueEl = self.CreateElementWithData("value",event["rating"])

ratingEl.appendChild(valueEl)

programEl.appendChild(ratingEl)

return programEl

def BuildXMLDate(self,inTime):

output = inTime.replace('-','').replace('T','').replace(':','')

output = output.replace('Z',' +0000')

return output

def BuildChannelXML(self,channel):

channelEl = self.guideXML.createElement('channel')

channelEl.setAttribute('id',channel["channelId"])

dispName1 = self.CreateElementWithData("display-name",channel["channelNo"] + " " + channel["callSign"])

dispName2 = self.CreateElementWithData("display-name",channel["channelNo"])

dispName3 = self.CreateElementWithData("display-name",channel["callSign"])

dispName4 = self.CreateElementWithData("display-name",channel["affiliateName"].title())

iconEl = self.guideXML.createElement("icon")

iconEl.setAttribute("src","http://"+(channel["thumbnail"].partition('?')[0] or "").lstrip('/'))

channelEl.appendChild(dispName1)

channelEl.appendChild(dispName2)

channelEl.appendChild(dispName3)

channelEl.appendChild(dispName4)

channelEl.appendChild(iconEl)

return channelEl

def CreateElementWithData(self,name,data):

el = self.guideXML.createElement(name)

elText = self.guideXML.createTextNode(data)

el.appendChild(elText)

return el

def GetGuideTimes(self):

currentTimestamp = time.time()

currentTimestamp -= 60 * 60 * 24

halfHourOffset = currentTimestamp % (60 * 30)

currentTimestamp = currentTimestamp - halfHourOffset

days = 14

try:

days = int(self.get_config_value("prefs","guideDays", fallback="14"))

except:

print("guideDays not in config. using default: 14")

print("Loading guide data for ",days," days")

endTimeStamp = currentTimestamp + (60 * 60 * 24 * days)

return (currentTimestamp,endTimeStamp)

def BuildRootEl(self):

self.rootEl = self.guideXML.createElement('tv')

self.rootEl.setAttribute("source-info-url","http://tvlistings.gracenote.com/")

self.rootEl.setAttribute("source-info-name","zap2it")

self.rootEl.setAttribute("generator-info-name","zap2it-GuideScraping)")

self.rootEl.setAttribute("generator-info-url","daniel@widrick.net")

def BuildGuide(self):

self.Authenticate()

time.sleep(5)

self.guideXML = xml.dom.minidom.Document()

impl = xml.dom.minidom.getDOMImplementation()

doctype = impl.createDocumentType("tv","","xmltv.dtd")

self.guideXML.appendChild(doctype)

self.BuildRootEl()

addChannels = True;

times = self.GetGuideTimes()

loopTime = times[0]

zipCodes = loadZipCodes()

while(loopTime < times[1]):

for zipCode in zipCodes:

zipCode = str(zipCode)

zipCode = zipCode.strip()

zip_json = self.GetData(loopTime,zipCode)

time.sleep(5)

if addChannels:

self.AddChannelsToGuide(zip_json)

self.AddEventsToGuide(zip_json)

addChannels = False

loopTime += (60 * 60 * 3)

self.guideXML.appendChild(self.rootEl)

self.WriteGuide()

self.CopyHistorical()

self.CleanHistorical()

def WriteGuide(self):

with open(self.outputFile,"wb") as file:

file.write(self.guideXML.toprettyxml().encode("utf8"))

def CopyHistorical(self):

dateTimeObj = datetime.datetime.now()

timestampStr = "." + dateTimeObj.strftime("%Y%m%d%H%M%S") + '.xmltv'

histGuideFile = timestampStr.join(optGuideFile.rsplit('.xmltv',1))

with open(histGuideFile,"wb") as file:

file.write(self.guideXML.toprettyxml().encode("utf8"))

def CleanHistorical(self):

outputFilePath = os.path.abspath(self.outputFile)

outputDir = os.path.dirname(outputFilePath)

for item in os.listdir(outputDir):

fileName = os.path.join(outputDir,item)

if os.path.isfile(fileName) & item.endswith('.xmltv'):

histGuideDays = self.get_config_value("prefs","historicalGuideDays", fallback="30")

if (time.time() - os.stat(fileName).st_mtime) >= int(histGuideDays) * 86400:

os.remove(fileName)

def showAvailableChannels(self):

allJSON = []

self.Authenticate()

for zipCode in loadZipCodes():

zipCode = str(zipCode)

zipCode = zipCode.strip()

print("Loading available channels for: ",zipCode)

my_json = guide.GetData(time.time(), zipCode)

allJSON.append(my_json)

channelList = {}

for zip in allJSON:

for channel in zip["channels"]:

chanid = channel.get("channelId")

chanid = int(chanid)

channelList[chanid] = channel.get("callSign") + "::" + channel.get("channelNo")

print(f'{"CHAN ID":<15}|{"name":<40}|',end='')

for channel in channelList:

print(f'{channel:<15}|',end='')

zipCodes = guide.get_config_value("prefs","zipCode", fallback="")

if zipCodes == "":

print("No Zip Codes configured in config.ini")

print("Please set the zipCode in the config.ini file under [prefs] section")

exit(1)

try:

zipCodes = json.loads(zipCodes)

if not isinstance(zipCodes,list):

zipCodes = [zipCodes]

except json.JSONDecodeError:

zipCodes = [zipCodes] #Support the old format

print("Loaded Zip Codes: ",zipCodes)

def do_GET(self):

if self.path == '/xmlguide.xmltv':

self.send_response(200)

self.send_header("Content-type","text/xml")

self.end_headers()

with open(optGuideFile,"rb") as file:

self.wfile.write(file.read())

else:

self.send_response(404)

self.end_headers()

while True:

guide.BuildGuide()

print("Guide Updated")