import datetime
import contextlib
import six.moves.urllib.request, six.moves.urllib.parse, six.moves.urllib.error
from .kodijsonrpc import rpc
from kodi_six import xbmc
from kodi_six import xbmcgui
from kodi_six import xbmcaddon
from plexnet import signalsmixin
import six
DEBUG = True
_SHUTDOWN = False
ADDON = xbmcaddon.Addon()
PROFILE = xbmc.translatePath(ADDON.getAddonInfo('profile'))
SETTINGS_LOCK = threading.Lock()
_splitver = xbmc.getInfoLabel('System.BuildVersion').split()[0].split(".")
KODI_VERSION_MAJOR, KODI_VERSION_MINOR = int(_splitver[0].split("-")[0]), int(_splitver[1].split("-")[0])
class UtilityMonitor(xbmc.Monitor, signalsmixin.SignalsMixin):
def __init__(self, *args, **kwargs):
xbmc.Monitor.__init__(self, *args, **kwargs)
signalsmixin.SignalsMixin.__init__(self)
def watchStatusChanged(self):
from kodi_six import xbmc, xbmcaddon
import client
from database import get_credentials, save_credentials
from dialogs import ServerConnect, UsersConnect, LoginManual, ServerManual
from helper import settings, addon_id, event, api, window
from jellyfin import Jellyfin
from jellyfin.connection_manager import CONNECTION_STATE
from helper.exceptions import HTTPException
from helper import LazyLogger
##################################################################################################
LOG = LazyLogger(__name__)
XML_PATH = (xbmcaddon.Addon(addon_id()).getAddonInfo('path'), "default",
"1080i")
##################################################################################################
class Connect(object):
def __init__(self):
self.info = client.get_info()
def register(self, server_id=None, options={}):
''' Login into server. If server is None, then it will show the proper prompts to login, etc.
If a server id is specified then only a login dialog will be shown for that server.
'''
LOG.info("--[ server/%s ]", server_id or 'default')
credentials = dict(get_credentials())
def get_themes(api_client):
''' Add theme media locally, via strm. This is only for tv tunes.
If another script is used, adjust this code.
'''
from helper.utils import normalize_string
from helper.playutils import PlayUtils
from helper.xmls import tvtunes_nfo
library = xbmc.translatePath(
"special://profile/addon_data/plugin.video.jellyfin/library")
play = settings('useDirectPaths') == "1"
if not xbmcvfs.exists(library + '/'):
xbmcvfs.mkdir(library)
if xbmc.getCondVisibility('System.HasAddon(script.tvtunes)'):
tvtunes = xbmcaddon.Addon(id="script.tvtunes")
tvtunes.setSetting('custom_path_enable', "true")
tvtunes.setSetting('custom_path', library)
LOG.info("TV Tunes custom path is enabled and set.")
else:
dialog("ok", "{jellyfin}", translate(33152))
return
with Database('jellyfin') as jellyfindb:
all_views = jellyfin_db.JellyfinDatabase(jellyfindb.cursor).get_views()
views = [
x[0] for x in all_views if x[2] in ('movies', 'tvshows', 'mixed')
]
items = {}
server = api_client.config.data['auth.server']
for view in views:
result = api_client.get_items_theme_video(view)
for item in result['Items']:
folder = normalize_string(item['Name'])
items[item['Id']] = folder
result = api_client.get_items_theme_song(view)
for item in result['Items']:
folder = normalize_string(item['Name'])
items[item['Id']] = folder
for item in items:
nfo_path = os.path.join(library, items[item])
nfo_file = os.path.join(nfo_path, "tvtunes.nfo")
if not xbmcvfs.exists(nfo_path):
xbmcvfs.mkdir(nfo_path)
themes = api_client.get_themes(item)
paths = []
for theme in themes['ThemeVideosResult']['Items'] + themes[
'ThemeSongsResult']['Items']:
putils = PlayUtils(theme, False, None, server, api_client)
if play:
paths.append(putils.direct_play(theme['MediaSources'][0]))
else:
paths.append(putils.direct_url(theme['MediaSources'][0]))
tvtunes_nfo(nfo_file, paths)
dialog("notification",
heading="{jellyfin}",
message=translate(33153),
icon="{jellyfin}",
time=1000,
sound=False)
def _inputstream_version(self):
addon = xbmcaddon.Addon(self.inputstream_addon)
return addon.getAddonInfo('version')
def __init__(self):
try:
from urllib.parse import urlparse
except ImportError:
from urlparse import urlparse
# argv[0] can contain the entire path, so we limit ourselves to the base url
pid = urlparse(argv[0])
self.pluginid = '{}://{}/'.format(pid.scheme, pid.netloc)
self.pluginhandle = int(
argv[1]) if (1 < len(argv)) and self.pluginid else -1
self._globals['monitor'] = xbmc.Monitor()
self._globals['addon'] = xbmcaddon.Addon()
self._globals['dialog'] = xbmcgui.Dialog()
# self._globals['dialogprogress'] = xbmcgui.DialogProgress()
self._globals['hasExtRC'] = xbmc.getCondVisibility(
'System.HasAddon(script.chromium_remotecontrol)')
self._globals['DATA_PATH'] = py2_decode(
xbmc.translatePath(self.addon.getAddonInfo('profile')))
self._globals['CONFIG_PATH'] = OSPJoin(self._globals['DATA_PATH'],
'config')
self._globals['HOME_PATH'] = py2_decode(
xbmc.translatePath('special://home'))
self._globals['PLUGIN_PATH'] = py2_decode(
self._globals['addon'].getAddonInfo('path'))
# With main PATHs configured, we initialise the get/write path attributes
# and generate/retrieve the device ID
getConfig.configPath = self._globals['CONFIG_PATH']
writeConfig.configPath = self._globals['CONFIG_PATH']
self._globals['deviceID'] = self.genID()
self._globals['__plugin__'] = self._globals['addon'].getAddonInfo(
'name')
self._globals['__authors__'] = self._globals['addon'].getAddonInfo(
'author')
self._globals['__credits__'] = ""
self._globals['__version__'] = self._globals['addon'].getAddonInfo(
'version')
# OS Detection
if xbmc.getCondVisibility('system.platform.windows'):
self._globals['platform'] |= self.OS_WINDOWS
if xbmc.getCondVisibility('system.platform.linux'):
self._globals['platform'] |= self.OS_LINUX
if xbmc.getCondVisibility('system.platform.osx'):
self._globals['platform'] |= self.OS_OSX
if xbmc.getCondVisibility('system.platform.android'):
self._globals['platform'] |= self.OS_ANDROID
if (xbmcvfs.exists('/etc/os-release')) and (
'libreelec' in xbmcvfs.File('/etc/os-release').read()):
self._globals['platform'] |= self.OS_LE
# Save the language code for HTTP requests and set the locale for l10n
loc = getdefaultlocale()[0]
userAcceptLanguages = 'en-gb{}, en;q=0.5'
self._globals['userAcceptLanguages'] = userAcceptLanguages.format(
'') if not loc else '{}, {}'.format(
loc.lower().replace('_', '-'),
userAcceptLanguages.format(';q=0.75'))
self._globals['CONTEXTMENU_MULTIUSER'] = [
(getString(30130, self._globals['addon']).split('…')[0],
'RunPlugin({}?mode=LogIn)'.format(self.pluginid)),
(getString(30131, self._globals['addon']).split('…')[0],
'RunPlugin({}?mode=removeUser)'.format(self.pluginid)),
(getString(30132, self._globals['addon']),
'RunPlugin({}?mode=renameUser)'.format(self.pluginid))
]
try:
pub, media_list = download_pub_data(pubdata)
item = next(MediaItem(m) for m in media_list if m.track == track)
if resolve:
xbmcplugin.setResolvedUrl(addon_handle, True, item.listitem_with_resolved_url())
else:
pl = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
pl.clear()
pl.add(item.resolved_url, item.listitem())
xbmc.Player().play(pl)
except (NotFoundError, StopIteration):
xbmcgui.Dialog().ok('', S.NOT_AVAIL)
addon_handle = int(sys.argv[1]) # needed for gui
addon = xbmcaddon.Addon() # needed for info
global_language = addon.getSetting(SettingID.LANG) or 'E'
enable_scrapper = addon.getSetting(SettingID.SCRAPPER) == 'true'
addon_dir = xbmc.translatePath(addon.getAddonInfo('profile'))
try:
os.makedirs(addon_dir) # needed first run
except OSError:
pass
cache_path = os.path.join(addon_dir, 'cache.db')
# Special class that will lookup its values in Kodi's language file
S = LocalizedStringID(addon.getLocalizedString)
# Tested in Kodi 18: disables all viewtypes except list, and there will be no icons in the list
xbmcplugin.setContent(addon_handle, 'files')
provider_results = []
provider_cache = {}
available_providers = 0
request_time = time.time()
use_kodi_language = get_setting('kodi_language', bool)
auto_timeout = get_setting("auto_timeout", bool)
timeout = get_setting("timeout", int)
debug_parser = get_setting("use_debug_parser", bool)
max_results = get_setting('max_results', int)
sort_by = get_setting('sort_by', int)
special_chars = "()\"':.[]<>/\\?"
elementum_timeout = 0
elementum_addon = xbmcaddon.Addon(id='plugin.video.elementum')
if elementum_addon:
if elementum_addon.getSetting('custom_provider_timeout_enabled') == "true":
elementum_timeout = int(
elementum_addon.getSetting('custom_provider_timeout'))
else:
elementum_timeout = 30
log.info("Using timeout from Elementum: %d seconds" % (elementum_timeout))
# Make sure timeout is always less than the one from Elementum.
if auto_timeout:
timeout = elementum_timeout - 3
elif elementum_timeout > 0 and timeout > elementum_timeout - 3:
log.info(
"Redefining timeout to be less than Elementum's: %d to %d seconds" %
(timeout, elementum_timeout - 3))
else:
raise RuntimeError
def request_to_self(query):
"""Return a string with an URL request to the add-on itself"""
# argv[0] is path to the plugin
return sys.argv[0] + '?' + urlencode(query)
if __name__ == '__main__':
# To send stuff to the screen
addon_handle = int(sys.argv[1])
# To get settings and info
addon = xbmcaddon.Addon()
# For logging purpose
addon_id = addon.getAddonInfo('id')
# To to get translated strings
S = LocalizedStringID(addon.getLocalizedString)
video_res = [1080, 720, 480, 360,
240][int(addon.getSetting(SettingID.RESOLUTION))]
subtitle_setting = addon.getSetting(SettingID.SUBTITLES) == 'true'
global_lang = addon.getSetting(SettingID.LANGUAGE) or 'E'
# The awkward way Kodi passes arguments to the add-on...
# argv[2] is a URL query string, probably passed by request_to_self()
# example: ?mode=play&media=ThisVideo
args = parse_qs(sys.argv[2][1:])
# parse_qs puts the values in a list, so we grab the first value for each key
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/>.
"""
from kodi_six import xbmc, xbmcgui, xbmcplugin, xbmcaddon, xbmcvfs
from six.moves import urllib_parse
import six
import sys
import os
import re
import time
from resolveurl.lib import strings
from resolveurl.lib import CustomProgressDialog
addon = xbmcaddon.Addon('script.module.resolveurl')
get_setting = addon.getSetting
show_settings = addon.openSettings
sleep = xbmc.sleep
_log = xbmc.log
def get_path():
return addon.getAddonInfo('path')
def get_profile():
return addon.getAddonInfo('profile')
def translate_path(path):
# -*- coding: UTF-8 -*-
import pkgutil
import os
from . import sources_koditvrscrapers
try:
from kodi_six import xbmcaddon
__addon__ = xbmcaddon.Addon(id='script.module.koditvrscrapers')
except:
__addon__ = None
pass
def sources():
try:
sourceDict = []
if __addon__ is not None:
provider = __addon__.getSetting('package.folder')
else:
provider = 'koditvrscrapers'
sourceFolder = getScraperFolder(provider)
sourceFolderLocation = os.path.join(os.path.dirname(__file__),
sourceFolder)
sourceSubFolders = [x[1] for x in os.walk(sourceFolderLocation)][0]
for i in sourceSubFolders:
for loader, module_name, is_pkg in pkgutil.walk_packages(
[os.path.join(sourceFolderLocation, i)]):
if is_pkg:
continue
def idle():
if float(xbmcaddon.Addon('xbmc.addon').getAddonInfo('version')[:4]) > 17.6:
execute('Dialog.Close(busydialognocancel)')
else:
execute('Dialog.Close(busydialog)')
def busy():
if float(xbmcaddon.Addon('xbmc.addon').getAddonInfo('version')[:4]) > 17.6:
execute('ActivateWindow(busydialognocancel)')
else:
execute('ActivateWindow(busydialog)')
#!/usr/bin/python
# -*- coding: utf-8 -*-
from kodi_six import xbmc, xbmcaddon, xbmcgui
import resources.lib.ColorPicker as cp
ADDON_ID = "script.skin.helper.colorpicker"
ADDON = xbmcaddon.Addon(ADDON_ID)
ADDON_PATH = ADDON.getAddonInfo('path')
MONITOR = xbmc.Monitor()
class Main(object):
'''Main entrypoint for our colorpicker'''
def __init__(self):
params = self.get_params()
if params:
color_picker = cp.ColorPicker("script-skin_helper_service-ColorPicker.xml", ADDON_PATH, "Default", "1080i")
color_picker.skinstring = params.get("SKINSTRING","")
color_picker.win_property = params.get("WINPROPERTY","")
color_picker.active_palette = params.get("PALETTE","")
color_picker.header_label = params.get("HEADER","")
propname = params.get("SHORTCUTPROPERTY","")
color_picker.shortcut_property = propname
color_picker.doModal()
#special action when we want to set our chosen color into a skinshortcuts property
if propname and not isinstance(color_picker.result, int):
self.wait_for_skinshortcuts_window()
xbmc.sleep(400)
current_window = xbmcgui.Window( xbmcgui.getCurrentWindowDialogId() )
current_window.setProperty("customProperty", propname)
import sys
import re
import json
from six.moves import urllib_request, urllib_parse, http_cookiejar
from kodi_six import xbmc, xbmcaddon, xbmcplugin, xbmcgui
xbmcaddon.Addon(id='plugin.video.empflix')
cookiejar = http_cookiejar.LWPCookieJar()
cookie_handler = urllib_request.HTTPCookieProcessor(cookiejar)
urllib_request.build_opener(cookie_handler)
def CATEGORIES():
link = openURL('https://www.empflix.com/categories')
match = re.compile(r'class="col-6.+?href="([^"]+)">\s*<img.+?src="([^"]+).+?title">([^<]+)', re.DOTALL).findall(link)
addDir('All', 'https://www.empflix.com/', 1, '', 1)
for url, thumb, name in match:
addDir(name,
url,
2, thumb, 1)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def SORTMETHOD(url):
if url == 'https://www.empflix.com/':
addDir('Featured', url + 'featured', 2, '', 1)
addDir('Most Recent', url + 'new', 2, '', 1)
addDir('Top Rated', url + 'toprated', 2, '', 1)
else:
match = re.compile('(https://www.empflix.com/channels/)'
import six
from six.moves import urllib_parse, range
import re
import json
import os
import sys
from kodi_six import xbmcplugin, xbmcaddon, xbmcgui, xbmc, xbmcvfs
# python 2 and 3 compatibility defs
TRANSLATEPATH = xbmcvfs.translatePath if six.PY3 else xbmc.translatePath
#addon name
__addonname__ = 'plugin.video.fantasticc'
#get path the default.py is in.
__addonpath__ = xbmcaddon.Addon(id=__addonname__).getAddonInfo('path')
#datapath
__datapath__ = TRANSLATEPATH('special://profile/addon_data/' + __addonname__)
#append lib directory
sys.path.append(os.path.join(__addonpath__, 'resources', 'lib'))
#import from lib directory
import weblogin
import gethtml
pluginhandle = int(sys.argv[1])
# example of how to get path to an image
default_image = os.path.join(__addonpath__, 'resources', 'images',
def getElementumLocalizedString(stringId):
ELEMENTUM_ADDON = xbmcaddon.Addon('plugin.video.elementum')
try:
return py2_encode(ELEMENTUM_ADDON.getLocalizedString(stringId), 'utf-8', 'ignore')
except:
return stringId
import os
from kodi_six import xbmc, xbmcaddon
##### ADDON ####
ADDON = xbmcaddon.Addon(os.environ.get('ADDON_ID', ''))
ADDON_ID = ADDON.getAddonInfo('id')
ADDON_VERSION = ADDON.getAddonInfo('version')
ADDON_NAME = ADDON.getAddonInfo('name')
ADDON_PATH = xbmc.translatePath(ADDON.getAddonInfo('path'))
ADDON_PROFILE = xbmc.translatePath(ADDON.getAddonInfo('profile'))
ADDON_ICON = ADDON.getAddonInfo('icon')
ADDON_FANART = ADDON.getAddonInfo('fanart')
ADDON_DEV = bool(int(os.environ.get('ADDON_DEV', '0')))
#################
#### DATABASE #####
DB_PATH = os.path.join(ADDON_PROFILE, 'data.db')
DB_MAX_INSERTS = 100
DB_PRAGMAS = {
'journal_mode': 'wal',
'cache_size': -1 * 10000, #10MB
'foreign_keys': 1,
'ignore_check_constraints': 0,
'synchronous': 0
}
DB_TABLENAME = '_db'
###################
##### USERDATA ####
USERDATA_KEY = '_userdata'
def process(provider, generator, filtering, has_special, verify_name=True, verify_size=True, skip_auth=False):
""" Method for processing provider results using its generator and Filtering class instance
Args:
provider (str): Provider ID
generator (function): Generator method, can be either ``extract_torrents`` or ``extract_from_api``
filtering (Filtering): Filtering class instance
has_special (bool): Whether title contains special chars
verify_name (bool): Whether to double-check the results' names match the query or not
verify_size (bool): Whether to check the results' file sizes
"""
log.debug("[%s] execute_process for %s with %s" % (provider, provider, repr(generator)))
definition = definitions[provider]
definition = get_alias(definition, get_setting("%s_alias" % provider))
client = Client(info=filtering.info, request_charset=definition['charset'], response_charset=definition['response_charset'])
token = None
logged_in = False
token_auth = False
if get_setting('kodi_language', bool):
kodi_language = xbmc.getLanguage(xbmc.ISO_639_1)
if kodi_language:
filtering.kodi_language = kodi_language
language_exceptions = get_setting('language_exceptions')
if language_exceptions.strip().lower():
filtering.language_exceptions = re.split(r',\s?', language_exceptions)
log.debug("[%s] Queries: %s" % (provider, filtering.queries))
log.debug("[%s] Extras: %s" % (provider, filtering.extras))
for query, extra in zip(filtering.queries, filtering.extras):
log.debug("[%s] Before keywords - Query: %s - Extra: %s" % (provider, repr(query), repr(extra)))
if has_special:
# Removing quotes, surrounding {title*} keywords, when title contains special chars
query = re.sub("[\"']({title.*?})[\"']", '\\1', query)
query = filtering.process_keywords(provider, query)
extra = filtering.process_keywords(provider, extra)
if extra == '-' and filtering.results:
continue
try:
if 'charset' in definition and definition['charset'] and 'utf' not in definition['charset'].lower():
query = quote(query.encode(definition['charset']))
extra = quote(extra.encode(definition['charset']))
else:
query = quote(py2_encode(query))
extra = quote(py2_encode(extra))
except Exception as e:
log.debug("[%s] Could not quote the query (%s): %s" % (provider, query, e))
pass
log.debug("[%s] After keywords - Query: %s - Extra: %s" % (provider, repr(query), repr(extra)))
if not query:
return filtering.results
url_search = filtering.url.replace('QUERY', query)
if extra and extra != '-':
url_search = url_search.replace('EXTRA', extra)
else:
url_search = url_search.replace('EXTRA', '')
url_search = url_search.replace(' ', definition['separator'])
if definition['separator'] != '%20':
url_search = url_search.replace('%20', definition['separator'])
# MagnetDL fix...
url_search = url_search.replace('FIRSTLETTER', query[:1])
# Creating the payload for POST method
if 'post_data' in definition and not filtering.post_data:
filtering.post_data = eval(definition['post_data'])
payload = dict()
for key, value in iteritems(filtering.post_data):
if 'QUERY' in value:
payload[key] = filtering.post_data[key].replace('QUERY', query)
else:
payload[key] = filtering.post_data[key]
payload[key] = urllib.unquote(payload[key])
# Creating the payload for GET method
headers = None
data = None
if filtering.get_data:
data = dict()
for key, value in iteritems(filtering.get_data):
if 'QUERY' in value:
data[key] = filtering.get_data[key].replace('QUERY', query)
else:
data[key] = filtering.get_data[key]
log.debug("- %s query: %s" % (provider, repr(query)))
log.debug("-- %s url_search before token: %s" % (provider, repr(url_search)))
log.debug("--- %s using POST payload: %s" % (provider, repr(payload)))
log.debug("----%s filtering with post_data: %s" % (provider, repr(filtering.post_data)))
# Set search's "title" in filtering to double-check results' names
if 'filter_title' in definition and definition['filter_title']:
filtering.filter_title = True
filtering.title = query
if 'initial_url' in definition and definition['initial_url']:
url = definition['initial_url']
if not url.startswith('http'):
url = definition['root_url'] + url
client.open(url)
if token:
log.info('[%s] Reusing existing token' % provider)
url_search = url_search.replace('TOKEN', token)
elif 'token' in definition:
token_url = definition['base_url'] + definition['token']
log.debug("[%s] Getting token for %s at %s" % (provider, provider, repr(token_url)))
client.open(py2_encode(token_url))
try:
token_data = json.loads(client.content)
except:
log.error('%s: Failed to get token for %s' % (provider, repr(url_search)))
return filtering.results
log.debug("[%s] Token response for %s: %s" % (provider, provider, repr(token_data)))
if 'token' in token_data:
token = token_data['token']
log.debug("[%s] Got token for %s: %s" % (provider, provider, repr(token)))
url_search = url_search.replace('TOKEN', token)
else:
log.warning('%s: Unable to get token for %s' % (provider, repr(url_search)))
if logged_in:
log.info("[%s] Reusing previous login" % provider)
elif token_auth:
log.info("[%s] Reusing previous token authorization" % provider)
elif 'private' in definition and definition['private']:
username = get_setting('%s_username' % provider, unicode)
password = get_setting('%s_password' % provider, unicode)
passkey = get_setting('%s_passkey' % provider, unicode)
if not username and not password and not passkey:
for addon_name in ('script.magnetic.%s' % provider, 'script.magnetic.%s-mc' % provider):
for setting in ('username', 'password'):
try:
value = xbmcaddon.Addon(addon_name).getSetting(setting)
set_setting('%s_%s' % (provider, setting), value)
if setting == 'username':
username = value
if setting == 'password':
password = value
except:
pass
if username:
client.username = username
url_search = url_search.replace('USERNAME', username)
if passkey:
logged_in = True
client.passkey = passkey
url_search = url_search.replace('PASSKEY', passkey)
elif 'login_object' in definition and definition['login_object']:
login_object = None
login_headers = None
logged_in = skip_auth
try:
login_object = definition['login_object'].replace('USERNAME', 'u"%s"' % username).replace('PASSWORD', 'u"%s"' % password)
except Exception as e:
log.error("Could not make login object for %s: %s" % (provider, e))
try:
if 'login_headers' in definition and definition['login_headers']:
login_headers = eval(definition['login_headers'])
except Exception as e:
log.error("Could not make login headers for %s: %s" % (provider, e))
# TODO generic flags in definitions for those...
if 'csrf_token' in definition and definition['csrf_token']:
client.open(definition['root_url'] + definition['login_path'])
if client.content:
csrf_token = re.search(r'name=\"_?csrf_token\" value=\"(.*?)\"', client.content)
if csrf_token:
login_object = login_object.replace('CSRF_TOKEN', '"%s"' % csrf_token.group(1))
else:
logged_in = True
if 'token_auth' in definition:
# log.debug("[%s] logging in with: %s" % (provider, login_object))
if client.open(definition['root_url'] + definition['token_auth'], post_data=eval(login_object)):
try:
token_data = json.loads(client.content)
except:
log.error('%s: Failed to get token from %s' % (provider, definition['token_auth']))
return filtering.results
log.debug("[%s] Token response for %s: %s" % (provider, provider, repr(token_data)))
if 'token' in token_data:
client.token = token_data['token']
log.debug("[%s] Auth token for %s: %s" % (provider, provider, repr(client.token)))
else:
log.error('[%s] Unable to get auth token for %s' % (provider, repr(url_search)))
return filtering.results
log.info('[%s] Token auth successful' % provider)
token_auth = True
else:
log.error("[%s] Token auth failed with response: %s" % (provider, repr(client.content)))
return filtering.results
elif not logged_in and client.login(definition['root_url'], definition['login_path'],
eval(login_object), login_headers, definition['login_failed']):
log.info('[%s] Login successful' % provider)
logged_in = True
elif not logged_in:
log.error("[%s] Login failed: %s", provider, client.status)
log.debug("[%s] Failed login content: %s", provider, repr(client.content))
return filtering.results
if logged_in:
if provider == 'hd-torrents':
client.open(definition['root_url'] + '/torrents.php')
csrf_token = re.search(r'name="csrfToken" value="(.*?)"', client.content)
url_search = url_search.replace("CSRF_TOKEN", csrf_token.group(1))
log.info("[%s] > %s search URL: %s" % (provider, definition['name'].rjust(longest), url_search))
if 'headers' in definition and definition['headers']:
headers = eval(definition['headers'])
log.info("[%s] > %s headers: %s" % (provider, definition['name'].rjust(longest), headers))
client.open(py2_encode(url_search), post_data=payload, get_data=data, headers=headers)
filtering.results.extend(
generate_payload(provider,
generator(provider, client),
filtering,
verify_name,
verify_size))
return filtering.results
def open_is_settings(self):
xbmcaddon.Addon(id='inputstream.adaptive').openSettings()
def __init__(self,
info=None,
request_charset='utf-8',
response_charset=None):
self._counter = 0
self._cookies_filename = ''
self._cookies = LWPCookieJar()
self.url = None
self.user_agent = USER_AGENT
self.content = None
self.status = None
self.username = None
self.token = None
self.passkey = None
self.info = info
self.proxy_url = None
self.request_charset = request_charset
self.response_charset = response_charset
self.needs_proxylock = False
self.headers = dict()
self.request_headers = None
self.session = requests.session()
self.session.verify = False
# Enabling retrying on failed requests
retries = Retry(total=3,
read=2,
connect=2,
redirect=3,
backoff_factor=0.5,
status_forcelist=[429, 500, 502, 503, 504])
self.session.mount('http://', HTTPAdapter(max_retries=retries))
self.session.mount('https://', HTTPAdapter(max_retries=retries))
# self.session = cfscrape.create_scraper()
# self.scraper = cfscrape.create_scraper()
# self.session = self.scraper.session()
global dns_public_list
global dns_opennic_list
dns_public_list = get_setting("public_dns_list",
unicode).replace(" ", "").split(",")
dns_opennic_list = get_setting("opennic_dns_list",
unicode).replace(" ", "").split(",")
# socket.setdefaulttimeout(60)
# Parsing proxy information
proxy = {
'enabled': get_setting("proxy_enabled", bool),
'use_type': get_setting("proxy_use_type", int),
'type': proxy_types[0],
'host': get_setting("proxy_host", unicode),
'port': get_setting("proxy_port", int),
'login': get_setting("proxy_login", unicode),
'password': get_setting("proxy_password", unicode),
}
try:
proxy['type'] = proxy_types[get_setting("proxy_type", int)]
except:
pass
if get_setting("use_public_dns", bool):
connection.create_connection = patched_create_connection
if get_setting("use_elementum_proxy", bool):
elementum_addon = xbmcaddon.Addon(id='plugin.video.elementum')
if elementum_addon and elementum_addon.getSetting(
'internal_proxy_enabled') == "true":
self.proxy_url = "{0}://{1}:{2}".format(
"http", "127.0.0.1", "65222")
if info and "internal_proxy_url" in info:
self.proxy_url = info["internal_proxy_url"]
self.session.proxies = {
'http': self.proxy_url,
'https': self.proxy_url,
}
elif proxy['enabled']:
if proxy['use_type'] == 0 and info and "proxy_url" in info:
log.debug("Setting proxy from Elementum: %s" %
(info["proxy_url"]))
elif proxy['use_type'] == 1:
log.debug("Setting proxy with custom settings: %s" %
(repr(proxy)))
if proxy['login'] or proxy['password']:
self.proxy_url = "{0}://{1}:{2}@{3}:{4}".format(
proxy['type'], proxy['login'], proxy['password'],
proxy['host'], proxy['port'])
else:
self.proxy_url = "{0}://{1}:{2}".format(
proxy['type'], proxy['host'], proxy['port'])
if self.proxy_url:
self.session.proxies = {
'http': self.proxy_url,
'https': self.proxy_url,
}
def autorun_addon():
if xbmcaddon.Addon().getSettingBool("auto_run"):
xbmc.executebuiltin('RunAddon(plugin.video.catchuptvandmore)')
return
import os
import logging
import traceback
from six import ensure_text
from kodi_six import xbmc, xbmcaddon
import database
from helper import get_filesystem_encoding
from . import settings
##################################################################################################
__addon__ = xbmcaddon.Addon(id='plugin.video.jellyfin')
__pluginpath__ = xbmc.translatePath(__addon__.getAddonInfo('path'))
##################################################################################################
def getLogger(name=None):
if name is None:
return __LOGGER
return __LOGGER.getChild(name)
class LogHandler(logging.StreamHandler):
def __init__(self):
# -*- coding: UTF-8 -*-
import os
import sys
import json
import time
import urllib
import urlparse
import shutil
import requests
from bs4 import BeautifulSoup
from kodi_six import xbmc, xbmcgui, xbmcaddon, xbmcplugin, xbmcvfs
__addon__ = xbmcaddon.Addon()
__author__ = __addon__.getAddonInfo('author')
__scriptid__ = __addon__.getAddonInfo('id')
__scriptname__ = __addon__.getAddonInfo('name')
__version__ = __addon__.getAddonInfo('version')
__language__ = __addon__.getLocalizedString
__cwd__ = xbmc.translatePath(__addon__.getAddonInfo('path')).decode("utf-8")
__profile__ = xbmc.translatePath(
__addon__.getAddonInfo('profile')).decode("utf-8")
__resource__ = xbmc.translatePath(os.path.join(__cwd__, 'resources',
'lib')).decode("utf-8")
__temp__ = xbmc.translatePath(os.path.join(__profile__,
'temp')).decode("utf-8")
sys.path.append(__resource__)
sys = reload(sys)
from urlparse import urljoin, urlparse, urlunparse, urlsplit, parse_qs
elif PYTHON3:
from urllib.parse import quote, unquote, quote_plus, unquote_plus, urlencode, urljoin, urlparse, urlunparse, urlsplit, parse_qs
from urllib.request import Request, urlopen, urlretrieve
from urllib.error import URLError
import time, datetime
from threading import Thread
import random # Zufallswerte für JobID
from resources.lib.util import *
import resources.lib.EPG as EPG
#from ardundzdf import MakeDetailText, LiveRecord
ADDON_ID = 'plugin.video.ardundzdf'
SETTINGS = xbmcaddon.Addon(id=ADDON_ID)
ADDON_PATH = SETTINGS.getAddonInfo('path')
ADDON_NAME = SETTINGS.getAddonInfo('name')
USERDATA = xbmc.translatePath("special://userdata")
ADDON_DATA = os.path.join("%sardundzdf_data") % USERDATA
if check_AddonXml('"xbmc.python" version="3.0.0"'):
ADDON_DATA = os.path.join("%s", "%s",
"%s") % (USERDATA, "addon_data", ADDON_ID)
DICTSTORE = os.path.join("%s/Dict") % ADDON_DATA
JOBFILE = os.path.join("%s/jobliste.xml") % ADDON_DATA
JOBFILE_LOCK = os.path.join(
"%s/jobliste.lck") % ADDON_DATA # Lockfile für Jobliste
JOB_STOP = os.path.join("%s/job_stop") % ADDON_DATA # Stopfile für JobMonitor
MONITOR_ALIVE = os.path.join(
import zipfile
import json
import time
import subprocess
import shutil
import re
from distutils.version import LooseVersion
from datetime import datetime, timedelta
import requests
import config
from kodi_six import xbmc, xbmcaddon, xbmcgui, xbmcvfs
ADDON = xbmcaddon.Addon('script.module.inputstreamhelper')
ADDON_PROFILE = xbmc.translatePath(ADDON.getAddonInfo('profile'))
LANGUAGE = ADDON.getLocalizedString
class Helper:
''' The main InputStream Helper class '''
def __init__(self, protocol, drm=None):
''' Initialize InputStream Helper class '''
self._log('Platform information: {0}'.format(platform.uname()))
self._url = None
self._download_path = None
self._loop_dev = None
self._modprobe_loop = False
