def CreateJsonVideoItem(self, resultSet):
Logger.Trace(resultSet)
url = "http://playapi.mtgx.tv/v3/videos/stream/%(id)s" % resultSet
item = mediaitem.MediaItem(resultSet["title"], url)
item.type = "video"
item.thumb = self.parentItem.thumb
item.icon = self.parentItem.icon
item.description = resultSet.get("summary", None)
airedAt = resultSet.get("airedAt", None)
if airedAt is None:
airedAt = resultSet.get("publishedAt", None)
if airedAt is not None:
# 2016-05-20T15:05:00+00:00
airedAt = airedAt.split("+")[0].rstrip('Z')
timeStamp = DateHelper.GetDateFromString(airedAt,
"%Y-%m-%dT%H:%M:%S")
item.SetDate(*timeStamp[0:6])
item.thumb = self.__GetThumbImage(resultSet.get("image"))
# webvttPath / samiPath
# loginRequired
isPremium = resultSet.get("loginRequired", False)
if isPremium and AddonSettings.HidePremiumItems():
Logger.Debug("Found premium item, hiding it.")
return None
srt = resultSet.get("samiPath")
if not srt:
srt = resultSet.get("subtitles_webvtt")
if srt:
Logger.Debug("Storing SRT/WebVTT path: %s", srt)
part = item.CreateNewEmptyMediaPart()
part.Subtitle = srt
return item
def ProcessFolderList(self, item=None):
"""Process the selected item and get's it's child items using the available dataparsers.
Arguments:
item : [opt] MediaItem - the selected item
Returns:
A list of MediaItems that form the childeren of the <item>.
Accepts an <item> and returns a list of MediaListems with at least name & url
set. The following actions are done:
* determining the correct parsers to use
* call a pre-processor
* parsing the data with the parsers
* calling the creators for item creations
if the item is NOne, we assume that we are dealing with the first call for this channel and the mainlist uri
is used.
"""
items = []
self.parentItem = item
if item is None:
Logger.Info("ProcessFolderList :: No item was specified. Assuming it was the main channel list")
url = self.mainListUri
headers = self.httpHeaders
elif len(item.items) > 0:
return item.items
else:
url = item.url
headers = item.HttpHeaders
if url.startswith("http:") or url.startswith("https:") or url.startswith("file:"):
data = UriHandler.Open(url, proxy=self.proxy, additionalHeaders=headers)
elif url.startswith("#"):
data = ""
elif url == "searchSite":
Logger.Debug("Starting to search")
return self.SearchSite()
else:
Logger.Debug("Unknown URL format. Setting data to ''")
data = ""
# Determine the handlers and process
dataParsers = self.__GetDataParsers(url)
# first check if there is a generic pre-processor
preProcs = filter(lambda p: p.IsGenericPreProcessor(), dataParsers)
numPreProcs = len(preProcs)
Logger.Trace("Processing %s Generic Pre-Processors DataParsers", numPreProcs)
if numPreProcs > 1:
# warn for strange results if more than 1 generic pre-processor is present.
Logger.Warning("More than one Generic Pre-Processor is found (%s). They are being processed in the "
"order that Python likes which might result in unexpected result.", numPreProcs)
for dataParser in preProcs:
# remove it from the list
dataParsers.remove(dataParser)
# and process it
Logger.Debug("Processing %s", dataParser)
(data, preItems) = dataParser.PreProcessor(data)
items += preItems
# The the other handlers
Logger.Trace("Processing %s Normal DataParsers", len(dataParsers))
handlerJson = None
for dataParser in dataParsers:
Logger.Debug("Processing %s", dataParser)
# Check for preprocessors
if dataParser.PreProcessor:
Logger.Debug("Processing DataParser.PreProcessor")
(handlerData, preItems) = dataParser.PreProcessor(data)
items += preItems
else:
handlerData = data
Logger.Debug("Processing DataParser.Parser")
if dataParser.Parser is None or (dataParser.Parser == "" and not dataParser.IsJson):
if dataParser.Creator:
Logger.Warning("No <parser> found for %s. Skipping.", dataParser.Creator)
continue
if dataParser.IsJson:
if handlerJson is None:
# Cache the json requests to improve performance
Logger.Trace("Caching JSON results for Dataparsing")
handlerJson = JsonHelper(handlerData, Logger.Instance())
Logger.Trace(dataParser.Parser)
parserResults = handlerJson.GetValue(fallback=[], *dataParser.Parser)
if not isinstance(parserResults, (tuple, list)):
# if there is just one match, return that as a list
parserResults = [parserResults]
else:
parserResults = Regexer.DoRegex(dataParser.Parser, handlerData)
Logger.Debug("Processing DataParser.Creator for %s items", len(parserResults))
for parserResult in parserResults:
handlerItem = dataParser.Creator(parserResult)
if handlerItem is not None:
items.append(handlerItem)
# should we exclude DRM/GEO?
hideGeoLocked = AddonSettings.HideGeoLockedItemsForLocation(self.language)
hideDrmProtected = AddonSettings.HideDrmItems()
hidePremium = AddonSettings.HidePremiumItems()
hideFolders = AddonSettings.HideRestrictedFolders()
typeToExclude = None
if not hideFolders:
typeToExclude = "folder"
oldCount = len(items)
if hideDrmProtected:
Logger.Debug("Hiding DRM items")
items = filter(lambda i: not i.isDrmProtected or i.type == typeToExclude, items)
if hideGeoLocked:
Logger.Debug("Hiding GEO Locked items due to GEO region: %s", self.language)
items = filter(lambda i: not i.isGeoLocked or i.type == typeToExclude, items)
if hidePremium:
Logger.Debug("Hiding Premium items")
items = filter(lambda i: not i.isPaid or i.type == typeToExclude, items)
# items = filter(lambda i: not i.isPaid or i.type == "folder", items)
if len(items) != oldCount:
Logger.Info("Hidden %s items due to DRM/GEO/Premium filter (Hide Folders=%s)",
oldCount - len(items), hideFolders)
# Check for grouping or not
limit = AddonSettings.GetListLimit()
folderItems = filter(lambda x: x.type.lower() == "folder", items)
# we should also de-duplicate before calculating
folderItems = list(set(folderItems))
folders = len(folderItems)
if 0 < limit < folders:
# let's filter them by alphabet if the number is exceeded
Logger.Debug("Creating Groups for list exceeding '%s' folder items. Total folders found '%s'.",
limit, folders)
other = LanguageHelper.GetLocalizedString(LanguageHelper.OtherChars)
titleFormat = LanguageHelper.GetLocalizedString(LanguageHelper.StartWith)
result = dict()
nonGrouped = []
# prefixes = ("de", "het", "the", "een", "a", "an")
for subItem in items:
if subItem.dontGroup or subItem.type != "folder":
nonGrouped.append(subItem)
continue
char = subItem.name[0].upper()
# Should we de-prefix?
# for p in prefixes:
# if subItem.name.lower().startswith(p + " "):
# char = subItem.name[len(p) + 1][0].upper()
if char.isdigit():
char = "0-9"
elif not char.isalpha():
char = other
if char not in result:
Logger.Trace("Creating Grouped item from: %s", subItem)
if char == other:
item = mediaitem.MediaItem(titleFormat.replace("'", "") % (char,), "")
else:
item = mediaitem.MediaItem(titleFormat % (char.upper(),), "")
item.thumb = self.noImage
item.complete = True
# item.SetDate(2100 + ord(char[0]), 1, 1, text='')
result[char] = item
else:
item = result[char]
item.items.append(subItem)
items = nonGrouped + result.values()
Logger.Trace("Found '%s' items", len(items))
return list(set(items))
