def __is_already_logged_on(self, username):
""" Check if the given user is logged on and sets what packages he/she has.
:param str username:
:return: Indicator if the user is alreadly logged in
:rtype: bool
"""
me = UriHandler.open("https://disco-api.dplay.se/users/me", proxy=self.proxy, no_cache=True)
if UriHandler.instance().status.code >= 300:
return False
account_data = JsonHelper(me)
signed_in_user = account_data.get_value("data", "attributes", "username")
if signed_in_user is not None and signed_in_user != username:
# Log out
UriHandler.open("https://disco-api.dplay.se/logout", data="", proxy=self.proxy, no_cache=True)
return False
logged_in = not account_data.get_value("data", "attributes", "anonymous")
if logged_in:
Logger.debug("Already logged in")
packages = account_data.get_value("data", "attributes", "packages", fallback=[])
self.__has_premium = "Premium" in packages
return True
else:
return False
def __update_embedded_video(self, item):
""" Updates video items that are encrypted. This could be the default for Krypton!
:param MediaItem item: The item to update.
:return: An updated item.
:rtype: MediaItem
"""
data = UriHandler.open(item.url, proxy=self.proxy)
if UriHandler.instance().status.code == 404:
title, message = Regexer.do_regex(
r'<h1>([^<]+)</h1>\W+<p>([^<]+)<', data)[0]
XbmcWrapper.show_dialog(title, message)
return item
start_needle = "var playerConfig ="
start_data = data.index(start_needle) + len(start_needle)
end_data = data.index("var talpaPlayer")
data = data[start_data:end_data].strip().rstrip(";")
json = JsonHelper(data)
has_drm_only = True
adaptive_available = AddonSettings.use_adaptive_stream_add_on(
with_encryption=False, channel=self)
adaptive_available_encrypted = AddonSettings.use_adaptive_stream_add_on(
with_encryption=True, channel=self)
for play_list_entry in json.get_value("playlist"):
part = item.create_new_empty_media_part()
for source in play_list_entry["sources"]:
stream_type = source["type"]
stream_url = source["file"]
stream_drm = source.get("drm")
if not stream_drm:
has_drm_only = False
if stream_type == "m3u8":
Logger.debug("Found non-encrypted M3u8 stream: %s",
stream_url)
M3u8.update_part_with_m3u8_streams(part,
stream_url,
proxy=self.proxy,
channel=self)
item.complete = True
elif stream_type == "dash" and adaptive_available:
Logger.debug("Found non-encrypted Dash stream: %s",
stream_url)
stream = part.append_media_stream(stream_url, 1)
Mpd.set_input_stream_addon_input(stream,
proxy=self.proxy)
item.complete = True
else:
Logger.debug("Unknown stream source: %s", source)
else:
compatible_drm = "widevine"
if compatible_drm not in stream_drm or stream_type != "dash":
Logger.debug("Found encrypted %s stream: %s",
stream_type, stream_url)
continue
Logger.debug("Found Widevine encrypted Dash stream: %s",
stream_url)
license_url = stream_drm[compatible_drm]["url"]
pid = stream_drm[compatible_drm]["releasePid"]
encryption_json = '{"getRawWidevineLicense":' \
'{"releasePid":"%s", "widevineChallenge":"b{SSM}"}' \
'}' % (pid,)
headers = {
"Content-Type": "application/json",
"Origin": "https://embed.kijk.nl",
"Referer": stream_url
}
encryption_key = Mpd.get_license_key(
license_url,
key_type=None,
key_value=encryption_json,
key_headers=headers)
stream = part.append_media_stream(stream_url, 0)
Mpd.set_input_stream_addon_input(
stream, proxy=self.proxy, license_key=encryption_key)
item.complete = True
subs = [
s['file'] for s in play_list_entry.get("tracks", [])
if s.get('kind') == "captions"
]
if subs:
subtitle = SubtitleHelper.download_subtitle(subs[0],
format="webvtt")
part.Subtitle = subtitle
if has_drm_only and not adaptive_available_encrypted:
XbmcWrapper.show_dialog(
LanguageHelper.get_localized_string(LanguageHelper.DrmTitle),
LanguageHelper.get_localized_string(
LanguageHelper.WidevineLeiaRequired))
return item
def update_json_video_item(self, item):
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
headers = {"accept": "application/vnd.sbs.ovp+json; version=2.0"}
data = UriHandler.open(item.url,
proxy=self.proxy,
additional_headers=headers)
if UriHandler.instance().status.code == 404:
Logger.warning("No normal stream found. Trying newer method")
new_url = item.url.replace("https://embed.kijk.nl/api/",
"https://embed.kijk.nl/")
item.url = new_url[:new_url.index("?")]
return self.__update_embedded_video(item)
json = JsonHelper(data)
embed_url = json.get_value("metadata", "embedURL")
if embed_url:
Logger.warning(
"Embed URL found. Using that to determine the streams.")
item.url = embed_url
try:
return self.__update_embedded_video(item)
except:
Logger.warning("Failed to update embedded item:",
exc_info=True)
use_adaptive_with_encryption = AddonSettings.use_adaptive_stream_add_on(
with_encryption=True, channel=self)
mpd_info = json.get_value("entitlements", "play")
# is there MPD information in the API response?
if mpd_info is not None:
return self.__update_video_from_mpd(item, mpd_info,
use_adaptive_with_encryption)
# Try the plain M3u8 streams
part = item.create_new_empty_media_part()
m3u8_url = json.get_value("playlist")
use_adaptive = AddonSettings.use_adaptive_stream_add_on(channel=self)
# with the Accept: application/vnd.sbs.ovp+json; version=2.0 header, the m3u8 streams that
# are brightcove based have an url parameter instead of an empty m3u8 file
Logger.debug("Trying standard M3u8 streams.")
if m3u8_url != "https://embed.kijk.nl/api/playlist/.m3u8" \
and "hostingervice=brightcove" not in m3u8_url:
for s, b in M3u8.get_streams_from_m3u8(m3u8_url,
self.proxy,
append_query_string=True):
if "_enc_" in s:
continue
if use_adaptive:
# we have at least 1 none encrypted streams
Logger.info("Using HLS InputStreamAddon")
strm = part.append_media_stream(m3u8_url, 0)
M3u8.set_input_stream_addon_input(strm, proxy=self.proxy)
item.complete = True
return item
part.append_media_stream(s, b)
item.complete = True
return item
Logger.warning("No M3u8 data found. Falling back to BrightCove")
video_id = json.get_value("vpakey")
# videoId = json.get_value("videoId") -> Not all items have a videoId
mpd_manifest_url = "https://embed.kijk.nl/video/%s?width=868&height=491" % (
video_id, )
referer = "https://embed.kijk.nl/video/%s" % (video_id, )
data = UriHandler.open(mpd_manifest_url,
proxy=self.proxy,
referer=referer)
# First try to find an M3u8
m3u8_urls = Regexer.do_regex('https:[^"]+.m3u8', data)
for m3u8_url in m3u8_urls:
m3u8_url = m3u8_url.replace("\\", "")
# We need the actual URI to make this work, so fetch it.
m3u8_url = UriHandler.header(m3u8_url, proxy=self.proxy)[-1]
Logger.debug("Found direct M3u8 in brightcove data.")
if use_adaptive:
# we have at least 1 none encrypted streams
Logger.info("Using HLS InputStreamAddon")
strm = part.append_media_stream(m3u8_url, 0)
M3u8.set_input_stream_addon_input(strm, proxy=self.proxy)
item.complete = True
return item
for s, b in M3u8.get_streams_from_m3u8(m3u8_url,
self.proxy,
append_query_string=True):
item.complete = True
part.append_media_stream(s, b)
return item
return self.__update_video_from_brightcove(
item, data, use_adaptive_with_encryption)
def __init__(self, addon_name, params, handle=0): # NOSONAR complexity
""" Initialises the plugin with given arguments.
:param str addon_name: The add-on name.
:param str params: The input parameters from the query string.
:param int handle: The Kodi directory handle.
"""
Logger.info("******** Starting %s add-on version %s/repo *********",
Config.appName, Config.version)
# noinspection PyTypeChecker
super(Plugin, self).__init__(addon_name, handle, params)
Logger.debug(self)
# Container Properties
self.propertyRetrospect = "Retrospect"
self.propertyRetrospectChannel = "RetrospectChannel"
self.propertyRetrospectChannelSetting = "RetrospectChannelSettings"
self.propertyRetrospectFolder = "RetrospectFolder"
self.propertyRetrospectVideo = "RetrospectVideo"
self.propertyRetrospectCloaked = "RetrospectCloaked"
self.propertyRetrospectCategory = "RetrospectCategory"
self.propertyRetrospectFavorite = "RetrospectFavorite"
self.propertyRetrospectAdaptive = "RetrospectAdaptive"
# channel objects
self.channelObject = None
self.channelFile = ""
self.channelCode = None
self.methodContainer = dict(
) # : storage for the inspect.getmembers(channel) method. Improves performance
# are we in session?
session_active = SessionHelper.is_session_active(Logger.instance())
# fetch some environment settings
env_ctrl = envcontroller.EnvController(Logger.instance())
if not session_active:
# do add-on start stuff
Logger.info("Add-On start detected. Performing startup actions.")
# print the folder structure
env_ctrl.print_retrospect_settings_and_folders(
Config, AddonSettings)
# show notification
XbmcWrapper.show_notification(None,
LanguageHelper.get_localized_string(
LanguageHelper.StartingAddonId) %
(Config.appName, ),
fallback=False,
logger=Logger)
# check for updates. Using local import for performance
from resources.lib.updater import Updater
up = Updater(Config.updateUrl, Config.version,
UriHandler.instance(), Logger.instance(),
AddonSettings.get_release_track())
if up.is_new_version_available():
Logger.info("Found new version online: %s vs %s",
up.currentVersion, up.onlineVersion)
notification = LanguageHelper.get_localized_string(
LanguageHelper.NewVersion2Id)
notification = notification % (Config.appName,
up.onlineVersion)
XbmcWrapper.show_notification(None,
lines=notification,
display_time=20000)
# check for cache folder
env_ctrl.cache_check()
# do some cache cleanup
env_ctrl.cache_clean_up(Config.cacheDir, Config.cacheValidTime)
# empty picklestore
self._pickler.purge_store(Config.addonId)
# create a session
SessionHelper.create_session(Logger.instance())
#===============================================================================
# Start the plugin version of progwindow
#===============================================================================
if len(self.params) == 0:
# Show initial start if not in a session
# now show the list
if AddonSettings.show_categories():
self.show_categories()
else:
self.show_channel_list()
#===============================================================================
# Start the plugin verion of the episode window
#===============================================================================
else:
# Determine what stage we are in. Check that there are more than 2 Parameters
if len(self.params) > 1 and self.keywordChannel in self.params:
# retrieve channel characteristics
self.channelFile = os.path.splitext(
self.params[self.keywordChannel])[0]
self.channelCode = self.params[self.keywordChannelCode]
Logger.debug(
"Found Channel data in URL: channel='%s', code='%s'",
self.channelFile, self.channelCode)
# import the channel
channel_register = ChannelIndex.get_register()
channel = channel_register.get_channel(self.channelFile,
self.channelCode)
if channel is not None:
self.channelObject = channel
else:
Logger.critical(
"None or more than one channels were found, unable to continue."
)
return
# init the channel as plugin
self.channelObject.init_channel()
Logger.info("Loaded: %s", self.channelObject.channelName)
elif self.keywordCategory in self.params \
or self.keywordAction in self.params and (
self.params[self.keywordAction] == self.actionAllFavourites or
self.params[self.keywordAction] == self.actionRemoveFavourite):
# no channel needed for these favourites actions.
pass
# ===============================================================================
# Vault Actions
# ===============================================================================
elif self.keywordAction in self.params and \
self.params[self.keywordAction] in \
(
self.actionSetEncryptedValue,
self.actionSetEncryptionPin,
self.actionResetVault
):
try:
# Import vault here, as it is only used here or in a channel
# that supports it
from resources.lib.vault import Vault
action = self.params[self.keywordAction]
if action == self.actionResetVault:
Vault.reset()
return
v = Vault()
if action == self.actionSetEncryptionPin:
v.change_pin()
elif action == self.actionSetEncryptedValue:
v.set_setting(
self.params[self.keywordSettingId],
self.params.get(self.keywordSettingName, ""),
self.params.get(self.keywordSettingActionId, None))
finally:
if self.keywordSettingTabFocus in self.params:
AddonSettings.show_settings(
self.params[self.keywordSettingTabFocus],
self.params.get(self.keywordSettingSettingFocus,
None))
return
elif self.keywordAction in self.params and \
self.actionPostLog in self.params[self.keywordAction]:
self.__send_log()
return
elif self.keywordAction in self.params and \
self.actionProxy in self.params[self.keywordAction]:
# do this here to not close the busy dialog on the SetProxy when
# a confirm box is shown
title = LanguageHelper.get_localized_string(
LanguageHelper.ProxyChangeConfirmTitle)
content = LanguageHelper.get_localized_string(
LanguageHelper.ProxyChangeConfirm)
if not XbmcWrapper.show_yes_no(title, content):
Logger.warning(
"Stopping proxy update due to user intervention")
return
language = self.params.get(self.keywordLanguage, None)
proxy_id = self.params.get(self.keywordProxy, None)
local_ip = self.params.get(self.keywordLocalIP, None)
self.__set_proxy(language, proxy_id, local_ip)
return
else:
Logger.critical("Error determining Plugin action")
return
#===============================================================================
# See what needs to be done.
#===============================================================================
if self.keywordAction not in self.params:
Logger.critical(
"Action parameters missing from request. Parameters=%s",
self.params)
return
elif self.params[self.keywordAction] == self.actionListCategory:
self.show_channel_list(self.params[self.keywordCategory])
elif self.params[
self.keywordAction] == self.actionConfigureChannel:
self.__configure_channel(self.channelObject)
elif self.params[self.keywordAction] == self.actionFavourites:
# we should show the favourites
self.show_favourites(self.channelObject)
elif self.params[self.keywordAction] == self.actionAllFavourites:
self.show_favourites(None)
elif self.params[self.keywordAction] == self.actionListFolder:
# channelName and URL is present, Parse the folder
self.process_folder_list()
elif self.params[self.keywordAction] == self.actionPlayVideo:
self.play_video_item()
elif not self.params[self.keywordAction] == "":
self.on_action_from_context_menu(
self.params[self.keywordAction])
else:
Logger.warning(
"Number of parameters (%s) or parameter (%s) values not implemented",
len(self.params), self.params)
self.__fetch_textures()
return
def __init__(self, addon_name, params, handle=0):
""" Initialises the plugin with given arguments.
:param str addon_name: The add-on name.
:param str params: The input parameters from the query string.
:param int|str handle: The Kodi directory handle.
"""
Logger.info("******** Starting %s add-on version %s/repo *********",
Config.appName, Config.version)
# noinspection PyTypeChecker
super(Plugin, self).__init__(addon_name, handle, params)
Logger.debug(self)
# are we in session?
session_active = SessionHelper.is_session_active(Logger.instance())
# fetch some environment settings
env_ctrl = envcontroller.EnvController(Logger.instance())
if not session_active:
# do add-on start stuff
Logger.info("Add-On start detected. Performing startup actions.")
# print the folder structure
env_ctrl.print_retrospect_settings_and_folders(
Config, AddonSettings)
# show notification
XbmcWrapper.show_notification(None,
LanguageHelper.get_localized_string(
LanguageHelper.StartingAddonId) %
(Config.appName, ),
fallback=False,
logger=Logger)
# check for updates. Using local import for performance
from resources.lib.updater import Updater
up = Updater(Config.updateUrl, Config.version,
UriHandler.instance(), Logger.instance(),
AddonSettings.get_release_track())
if up.is_new_version_available():
Logger.info("Found new version online: %s vs %s",
up.currentVersion, up.onlineVersion)
notification = LanguageHelper.get_localized_string(
LanguageHelper.NewVersion2Id)
notification = notification % (Config.appName,
up.onlineVersion)
XbmcWrapper.show_notification(None,
lines=notification,
display_time=20000)
# check for cache folder
env_ctrl.cache_check()
# do some cache cleanup
env_ctrl.cache_clean_up(Config.cacheDir, Config.cacheValidTime)
# empty picklestore
self.pickler.purge_store(Config.addonId)
# create a session
SessionHelper.create_session(Logger.instance())
def run_addon():
""" Runs Retrospect as a Video Add-On """
log_file = None
try:
from resources.lib.retroconfig import Config
from resources.lib.helpers.sessionhelper import SessionHelper
# get a logger up and running
from resources.lib.logger import Logger
# only append if there are no active sessions
if not SessionHelper.is_session_active():
# first call in the session, so do not append the log
append_log_file = False
else:
append_log_file = True
log_file = Logger.create_logger(os.path.join(Config.profileDir, Config.logFileNameAddon),
Config.appName,
append=append_log_file,
dual_logger=lambda x, y=4: xbmc.log(x, y))
from resources.lib.urihandler import UriHandler
from resources.lib.addonsettings import AddonSettings
AddonSettings.set_language()
from resources.lib.textures import TextureHandler
# update the loglevel
Logger.instance().minLogLevel = AddonSettings.get_log_level()
use_caching = AddonSettings.cache_http_responses()
cache_dir = None
if use_caching:
cache_dir = Config.cacheDir
ignore_ssl_errors = AddonSettings.ignore_ssl_errors()
UriHandler.create_uri_handler(cache_dir=cache_dir,
cookie_jar=os.path.join(Config.profileDir, "cookiejar.dat"),
ignore_ssl_errors=ignore_ssl_errors)
# start texture handler
TextureHandler.set_texture_handler(Config, Logger.instance(), UriHandler.instance())
# run the plugin
from resources.lib import plugin
plugin.Plugin(sys.argv[0], sys.argv[2], sys.argv[1])
# make sure we leave no references behind
AddonSettings.clear_cached_addon_settings_object()
# close the log to prevent locking on next call
Logger.instance().close_log()
log_file = None
except:
if log_file:
log_file.critical("Error running plugin", exc_info=True)
log_file.close_log()
raise
def log_on(self, username=None, password=None):
""" Logs on to a website, using an url.
:param username: If provided overrides the Kodi stored username
:param password: If provided overrides the Kodi stored username
:return: indication if the login was successful.
:rtype: bool
First checks if the channel requires log on. If so and it's not already
logged on, it should handle the log on. That part should be implemented
by the specific channel.
More arguments can be passed on, but must be handled by custom code.
After a successful log on the self.loggedOn property is set to True and
True is returned.
"""
username = username or AddonSettings.get_setting("dplayse_username")
if self.__is_already_logged_on(username):
return True
# Local import to not slow down any other stuff
import os
import binascii
try:
# If running on Leia
import pyaes
except:
# If running on Pre-Leia
from resources.lib import pyaes
import random
now = int(time.time())
b64_now = binascii.b2a_base64(str(now).encode()).decode().strip()
user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " \
"(KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36"
device_id = AddonSettings.get_client_id().replace("-", "")
window_id = "{}|{}".format(
binascii.hexlify(os.urandom(16)).decode(),
binascii.hexlify(os.urandom(16)).decode())
fe = [
"DNT:unknown", "L:en-US", "D:24", "PR:1", "S:1920,975",
"AS:1920,935", "TO:-120", "SS:true", "LS:true", "IDB:true",
"B:false", "ODB:true", "CPUC:unknown", "PK:Win32", "CFP:990181251",
"FR:false", "FOS:false", "FB:false", "JSF:Arial",
"P:Chrome PDF Plugin", "T:0,false,false", "H:4", "SWF:false"
]
fs_murmur_hash = '48bf49e1796939175b0406859d00baec'
data = [
{
"key": "api_type",
"value": "js"
},
{
"key": "p",
"value": 1
}, # constant
{
"key": "f",
"value": device_id
}, # browser instance ID
{
"key": "n",
"value": b64_now
}, # base64 encoding of time.now()
{
"key": "wh",
"value": window_id
}, # WindowHandle ID
{
"key": "fe",
"value": fe
}, # browser properties
{
"key": "ife_hash",
"value": fs_murmur_hash
}, # hash of browser properties
{
"key": "cs",
"value": 1
}, # canvas supported 0/1
{
"key": "jsbd",
"value": "{\"HL\":41,\"NCE\":true,\"DMTO\":1,\"DOTO\":1}"
}
]
data_value = JsonHelper.dump(data)
stamp = now - (now % (60 * 60 * 6))
key_password = "******".format(user_agent, stamp)
salt_bytes = os.urandom(8)
key_iv = self.__evp_kdf(key_password.encode(),
salt_bytes,
key_size=8,
iv_size=4,
iterations=1,
hash_algorithm="md5")
key = key_iv["key"]
iv = key_iv["iv"]
encrypter = pyaes.Encrypter(pyaes.AESModeOfOperationCBC(key, iv))
encrypted = encrypter.feed(data_value)
# Again, make a final call to flush any remaining bytes and strip padding
encrypted += encrypter.feed()
salt_hex = binascii.hexlify(salt_bytes)
iv_hex = binascii.hexlify(iv)
encrypted_b64 = binascii.b2a_base64(encrypted)
bda = {
"ct": encrypted_b64.decode(),
"iv": iv_hex.decode(),
"s": salt_hex.decode()
}
bda_str = JsonHelper.dump(bda)
bda_base64 = binascii.b2a_base64(bda_str.encode())
req_dict = {
"bda": bda_base64.decode(),
"public_key": "FE296399-FDEA-2EA2-8CD5-50F6E3157ECA",
"site": "https://client-api.arkoselabs.com",
"userbrowser": user_agent,
"simulate_rate_limit": "0",
"simulated": "0",
"rnd": "{}".format(random.random())
}
req_data = ""
for k, v in req_dict.items():
req_data = "{}{}={}&".format(req_data, k,
HtmlEntityHelper.url_encode(v))
req_data = req_data.rstrip("&")
arkose_data = UriHandler.open(
"https://client-api.arkoselabs.com/fc/gt2/public_key/FE296399-FDEA-2EA2-8CD5-50F6E3157ECA",
proxy=self.proxy,
data=req_data,
additional_headers={"user-agent": user_agent},
no_cache=True)
arkose_json = JsonHelper(arkose_data)
arkose_token = arkose_json.get_value("token")
if "rid=" not in arkose_token:
Logger.error("Error logging in. Invalid Arkose token.")
return False
Logger.debug("Succesfully required a login token from Arkose.")
UriHandler.open(
"https://disco-api.dplay.se/token?realm=dplayse&deviceId={}&shortlived=true"
.format(device_id),
proxy=self.proxy,
no_cache=True)
if username is None or password is None:
from resources.lib.vault import Vault
v = Vault()
password = v.get_setting("dplayse_password")
dplay_username = username
dplay_password = password
creds = {
"credentials": {
"username": dplay_username,
"password": dplay_password
}
}
headers = {
"x-disco-arkose-token": arkose_token,
"Origin": "https://auth.dplay.se",
"x-disco-client": "WEB:10:AUTH_DPLAY_V1:2.4.1",
# is not specified a captcha is required
# "Sec-Fetch-Site": "same-site",
# "Sec-Fetch-Mode": "cors",
# "Sec-Fetch-Dest": "empty",
"Referer": "https://auth.dplay.se/login",
"User-Agent": user_agent
}
result = UriHandler.open("https://disco-api.dplay.se/login",
proxy=self.proxy,
json=creds,
additional_headers=headers)
if UriHandler.instance().status.code > 200:
Logger.error("Failed to log in: %s", result)
return False
Logger.debug("Succesfully logged in")
return True
def download_subtitle(url,
file_name="",
format='sami',
proxy=None,
replace=None):
"""Downloads a SAMI and stores the SRT in the cache folder
Arguments:
@param url: string - URL location of the SAMI file
@param file_name: string - [opt] Filename to use to store the subtitle in SRT format.
if not specified, an MD5 hash of the URL with .xml
extension will be used
@param format: string - Defines the source format. Defaults to Sami.
@param proxy: Proxy - If specified, a proxy will be used
@param replace: dict - Dictionary with key to will be replaced with their values
@return: The full patch of the cached SRT file.
"""
if file_name == "":
Logger.debug(
"No filename present, generating filename using MD5 hash of url."
)
file_name = "%s.srt" % (EncodingHelper.encode_md5(url), )
elif not file_name.endswith(".srt"):
Logger.debug("No SRT extension present, appending it.")
file_name = "%s.srt" % (file_name, )
srt = ""
try:
local_complete_path = os.path.join(Config.cacheDir, file_name)
# no need to download it again!
if os.path.exists(local_complete_path):
return local_complete_path
Logger.trace("Opening Subtitle URL")
raw = UriHandler.open(url, proxy=proxy)
if UriHandler.instance().status.error:
Logger.warning("Could not retrieve subtitle from %s", url)
return ""
if raw == "":
Logger.warning(
"Empty Subtitle path found. Not setting subtitles.")
return ""
# try to decode it as `raw` should be a string.
if isinstance(raw, bytes):
try:
raw = raw.decode()
except:
# fix some weird chars
try:
raw = raw.replace("\x96", "-")
except:
Logger.error("Error replacing some weird chars.")
Logger.warning(
"Converting input to UTF-8 using 'unicode_escape'")
raw = raw.decode('unicode_escape')
# do some auto detection
if raw.startswith("WEBVTT") and format != "webvtt":
Logger.info(
"Discovered subtitle format 'webvtt' instead of '%s'",
format)
format = "webvtt"
if format.lower() == 'sami':
srt = SubtitleHelper.__convert_sami_to_srt(raw)
elif format.lower() == 'srt':
srt = raw
elif format.lower() == 'webvtt':
srt = SubtitleHelper.__convert_web_vtt_to_srt(
raw) # With Krypton and Leia VTT is supported natively
elif format.lower() == 'ttml':
srt = SubtitleHelper.__convert_ttml_to_srt(raw)
elif format.lower() == 'dcsubtitle':
srt = SubtitleHelper.__convert_dc_subtitle_to_srt(raw)
elif format.lower() == 'json':
srt = SubtitleHelper.__convert_json_subtitle_to_srt(raw)
elif format.lower() == 'm3u8srt':
srt = SubtitleHelper.__convert_m3u8_srt_to_subtitle_to_srt(
raw, url, proxy)
else:
error = "Uknown subtitle format: %s" % (format, )
raise NotImplementedError(error)
if replace:
Logger.debug("Replacing SRT data: %s", replace)
for needle in replace:
srt = srt.replace(needle, replace[needle])
with io.open(local_complete_path, 'w', encoding="utf-8") as f:
f.write(srt)
Logger.info("Saved SRT as %s", local_complete_path)
return local_complete_path
except:
Logger.error("Error handling Subtitle file: [%s]",
srt,
exc_info=True)
return ""
