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