stevazi/addon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Revert "Created branch develop"

Browse Source
This commit is contained in:
Alfa
2017-08-13 11:21:50 +02:00
committed by GitHub
parent 8000a6fd25
commit e549d644a9
395 changed files with 1849 additions and 10246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

458
plugin.video.alfa/platformcode/config.py
View File

@@ -1,458 +0,0 @@
# -*- coding: utf-8 -*-
# ------------------------------------------------------------
# Parámetros de configuración (kodi)
# ------------------------------------------------------------
import os
import re
import xbmc
import xbmcaddon
import xbmcgui
PLUGIN_NAME = "alfa"
__settings__ = xbmcaddon.Addon(id="plugin.video." + PLUGIN_NAME)
__language__ = __settings__.getLocalizedString
def get_platform(full_version=False):
"""
Devuelve la información la version de xbmc o kodi sobre el que se ejecuta el plugin
@param full_version: indica si queremos toda la informacion o no
@type full_version: bool
@rtype: str o dict
@return: Si el paramentro full_version es True se retorna un diccionario con las siguientes claves:
'num_version': (float) numero de version en formato XX.X
'name_version': (str) nombre clave de cada version
'video_db': (str) nombre del archivo que contiene la base de datos de videos
'plaform': (str) esta compuesto por "kodi-" o "xbmc-" mas el nombre de la version segun corresponda.
Si el parametro full_version es False (por defecto) se retorna el valor de la clave 'plaform' del diccionario anterior.
"""
ret = {}
codename = {"10": "dharma", "11": "eden", "12": "frodo",
"13": "gotham", "14": "helix", "15": "isengard",
"16": "jarvis", "17": "krypton", "18": "leia"}
code_db = {'10': 'MyVideos37.db', '11': 'MyVideos60.db', '12': 'MyVideos75.db',
'13': 'MyVideos78.db', '14': 'MyVideos90.db', '15': 'MyVideos93.db',
'16': 'MyVideos99.db', '17': 'MyVideos107.db', '18': 'MyVideos108.db'}
num_version = xbmc.getInfoLabel('System.BuildVersion')
num_version = re.match("\d+\.\d+", num_version).group(0)
ret['name_version'] = codename.get(num_version.split('.')[0], num_version)
ret['video_db'] = code_db.get(num_version.split('.')[0], "")
ret['num_version'] = float(num_version)
if ret['num_version'] < 14:
ret['platform'] = "xbmc-" + ret['name_version']
else:
ret['platform'] = "kodi-" + ret['name_version']
if full_version:
return ret
else:
return ret['platform']
def is_xbmc():
return True
def get_videolibrary_support():
return True
def get_system_platform():
""" fonction: pour recuperer la platform que xbmc tourne """
platform = "unknown"
if xbmc.getCondVisibility("system.platform.linux"):
platform = "linux"
elif xbmc.getCondVisibility("system.platform.windows"):
platform = "windows"
elif xbmc.getCondVisibility("system.platform.osx"):
platform = "osx"
return platform
def get_all_settings_addon():
# Lee el archivo settings.xml y retorna un diccionario con {id: value}
from core import scrapertools
infile = open(os.path.join(get_data_path(), "settings.xml"), "r")
data = infile.read()
infile.close()
ret = {}
matches = scrapertools.find_multiple_matches(data, '<setting id="([^"]*)" value="([^"]*)')
for _id, value in matches:
ret[_id] = get_setting(_id)
return ret
def open_settings():
settings_pre = get_all_settings_addon()
__settings__.openSettings()
settings_post = get_all_settings_addon()
# cb_validate_config (util para validar cambios realizados en el cuadro de dialogo)
if settings_post.get('adult_aux_intro_password', None):
# Hemos accedido a la seccion de Canales para adultos
from platformcode import platformtools
if 'adult_password' not in settings_pre:
adult_password = set_setting('adult_password', '0000')
else:
adult_password = settings_pre['adult_password']
if settings_post['adult_aux_intro_password'] == adult_password:
# La contraseña de acceso es correcta
# Cambio de contraseña
if settings_post['adult_aux_new_password1']:
if settings_post['adult_aux_new_password1'] == settings_post['adult_aux_new_password2']:
adult_password = set_setting('adult_password', settings_post['adult_aux_new_password1'])
else:
platformtools.dialog_ok("Canales para adultos",
"Los campos 'Nueva contraseña' y 'Confirmar nueva contraseña' no coinciden.",
"Entre de nuevo en 'Preferencias' para cambiar la contraseña")
# Fijar adult_pin
adult_pin = ""
if settings_post["adult_request_password"] == True:
adult_pin = adult_password
set_setting("adult_pin", adult_pin)
else:
platformtools.dialog_ok("Canales para adultos", "La contraseña no es correcta.",
"Los cambios realizados en esta sección no se guardaran.")
# Deshacer cambios
set_setting("adult_mode", settings_pre.get("adult_mode", 0))
set_setting("adult_request_password", settings_pre.get("adult_request_password", True))
# Borramos settings auxiliares
set_setting('adult_aux_intro_password', '')
set_setting('adult_aux_new_password1', '')
set_setting('adult_aux_new_password2', '')
# si se ha cambiado la ruta de la videoteca llamamos a comprobar directorios para que lo cree y pregunte
# automaticamente si configurar la videoteca
if settings_pre.get("videolibrarypath", None) != settings_post.get("videolibrarypath", None) or \
settings_pre.get("folder_movies", None) != settings_post.get("folder_movies", None) or \
settings_pre.get("folder_tvshows", None) != settings_post.get("folder_tvshows", None):
verify_directories_created()
else:
# si se ha puesto que se quiere autoconfigurar y se había creado el directorio de la videoteca
if not settings_pre.get("videolibrary_kodi", None) and settings_post.get("videolibrary_kodi", None) \
and settings_post.get("videolibrary_kodi_flag", None) == 1:
from platformcode import xbmc_videolibrary
xbmc_videolibrary.ask_set_content(2, silent=True)
def get_setting(name, channel="", server="", default=None):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global, en la configuracion propia del canal 'channel'
o en la del servidor 'server'.
Los parametros channel y server no deben usarse simultaneamente. Si se especifica el nombre del canal se devolvera
el resultado de llamar a channeltools.get_channel_setting(name, channel, default). Si se especifica el nombre del
servidor se devolvera el resultado de llamar a servertools.get_channel_setting(name, server, default). Si no se
especifica ninguno de los anteriores se devolvera el valor del parametro en la configuracion global si existe o
el valor default en caso contrario.
@param name: nombre del parametro
@type name: str
@param channel: nombre del canal
@type channel: str
@param server: nombre del servidor
@type server: str
@param default: valor devuelto en caso de que no exista el parametro name
@type default: cualquiera
@return: El valor del parametro 'name'
@rtype: El tipo del valor del parametro
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel json")
from core import channeltools
value = channeltools.get_channel_setting(name, channel, default)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Specific server setting
elif server:
# logger.info("config.get_setting reading server setting '"+name+"' from server json")
from core import servertools
value = servertools.get_server_setting(name, server, default)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(name)
if not value:
return default
# Translate Path if start with "special://"
if value.startswith("special://") and "videolibrarypath" not in name:
value = xbmc.translatePath(value)
# hack para devolver el tipo correspondiente
settings_types = get_settings_types()
if settings_types.get(name) in ['enum', 'number']:
try:
value = int(value)
except Exception, ex:
from platformcode import logger
logger.error("Error al convertir '%s' de tipo 'enum','number' \n%s" % (name, ex))
elif settings_types.get(name) == 'bool':
value = value == 'true'
elif name not in settings_types:
try:
if value in ['true', 'false']:
if value == 'true':
aux_val = True
else:
aux_val = False
value = bool(aux_val)
else:
t = eval(value)
value = t[0](t[1])
except Exception, ex:
from platformcode import logger
logger.error("Error al convertir '%s' se pasa como tipo 'None'\n%s" % (name, ex))
value = None
return value
def set_setting(name, value, channel="", server=""):
"""
Fija el valor de configuracion del parametro indicado.
Establece 'value' como el valor del parametro 'name' en la configuracion global o en la configuracion propia del
canal 'channel'.
Devuelve el valor cambiado o None si la asignacion no se ha podido completar.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.alfa\settings_channels el
archivo channel_data.json y establece el parametro 'name' al valor indicado por 'value'. Si el archivo
channel_data.json no existe busca en la carpeta channels el archivo channel.json y crea un archivo channel_data.json
antes de modificar el parametro 'name'.
Si el parametro 'name' no existe lo añade, con su valor, al archivo correspondiente.
Parametros:
name -- nombre del parametro
value -- valor del parametro
channel [opcional] -- nombre del canal
Retorna:
'value' en caso de que se haya podido fijar el valor y None en caso contrario
"""
if channel:
from core import channeltools
return channeltools.set_channel_setting(name, value, channel)
elif server:
from core import servertools
return servertools.set_server_setting(name, value, server)
else:
try:
settings_types = get_settings_types()
if settings_types.get(name) == 'bool':
if value:
new_value = "true"
else:
new_value = "false"
elif settings_types.get(name):
new_value = str(value)
else:
if isinstance(value, basestring):
new_value = "(%s, %s)" % (type(value).__name__, repr(value))
else:
new_value = "(%s, %s)" % (type(value).__name__, value)
__settings__.setSetting(name, new_value)
except Exception, ex:
from platformcode import logger
logger.error("Error al convertir '%s' no se guarda el valor \n%s" % (name, ex))
return None
return value
def get_settings_types():
"""
Devuelve un diccionario con los parametros (key) de la configuracion global y sus tipos (value)
:return: dict
"""
win10000 = xbmcgui.Window(10000)
settings_types = win10000.getProperty(PLUGIN_NAME + "_settings_types")
if not settings_types:
infile = open(os.path.join(get_runtime_path(), "resources", "settings.xml"))
data = infile.read()
infile.close()
matches = re.findall('<setting id="([^"]*)" type="([^"]*)', data)
settings_types = "{%s}" % ",".join("'%s': '%s'" % tup for tup in matches)
win10000.setProperty(PLUGIN_NAME + "_settings_types", settings_types)
return eval(settings_types)
def get_localized_string(code):
dev = __language__(code)
try:
dev = dev.encode("utf-8")
except:
pass
return dev
def get_videolibrary_config_path():
value = get_setting("videolibrarypath")
if value == "":
verify_directories_created()
value = get_setting("videolibrarypath")
return value
def get_videolibrary_path():
return xbmc.translatePath(get_videolibrary_config_path())
def get_temp_file(filename):
return xbmc.translatePath(os.path.join("special://temp/", filename))
def get_runtime_path():
return xbmc.translatePath(__settings__.getAddonInfo('Path'))
def get_data_path():
dev = xbmc.translatePath(__settings__.getAddonInfo('Profile'))
# Crea el directorio si no existe
if not os.path.exists(dev):
os.makedirs(dev)
return dev
def get_cookie_data():
import os
ficherocookies = os.path.join(get_data_path(), 'cookies.dat')
cookiedatafile = open(ficherocookies, 'r')
cookiedata = cookiedatafile.read()
cookiedatafile.close()
return cookiedata
# Test if all the required directories are created
def verify_directories_created():
from platformcode import logger
from core import filetools
from platformcode import xbmc_videolibrary
config_paths = [["videolibrarypath", "videolibrary"],
["downloadpath", "downloads"],
["downloadlistpath", "downloads/list"],
["settings_path", "settings_channels"]]
for path, default in config_paths:
saved_path = get_setting(path)
# videoteca
if path == "videolibrarypath":
if not saved_path:
saved_path = xbmc_videolibrary.search_library_path()
if saved_path:
set_setting(path, saved_path)
if not saved_path:
saved_path = "special://profile/addon_data/plugin.video." + PLUGIN_NAME + "/" + default
set_setting(path, saved_path)
saved_path = xbmc.translatePath(saved_path)
if not filetools.exists(saved_path):
logger.debug("Creating %s: %s" % (path, saved_path))
filetools.mkdir(saved_path)
config_paths = [["folder_movies", "CINE"],
["folder_tvshows", "SERIES"]]
flag_call = True
for path, default in config_paths:
saved_path = get_setting(path)
if not saved_path:
saved_path = default
set_setting(path, saved_path)
content_path = filetools.join(get_videolibrary_path(), saved_path)
if not filetools.exists(content_path):
logger.debug("Creating %s: %s" % (path, content_path))
# si se crea el directorio
if filetools.mkdir(content_path):
if flag_call:
# le pasamos el valor para que sepamos que se ha pasado por creación de directorio
xbmc_videolibrary.ask_set_content(1)
flag_call = False
try:
from core import scrapertools
# Buscamos el archivo addon.xml del skin activo
skindir = filetools.join(xbmc.translatePath("special://home"), 'addons', xbmc.getSkinDir(),
'addon.xml')
# Extraemos el nombre de la carpeta de resolución por defecto
folder = ""
data = filetools.read(skindir)
res = scrapertools.find_multiple_matches(data, '(<res .*?>)')
for r in res:
if 'default="true"' in r:
folder = scrapertools.find_single_match(r, 'folder="([^"]+)"')
break
# Comprobamos si existe en el addon y sino es así, la creamos
default = filetools.join(get_runtime_path(), 'resources', 'skins', 'Default')
if folder and not filetools.exists(filetools.join(default, folder)):
filetools.mkdir(filetools.join(default, folder))
# Copiamos el archivo a dicha carpeta desde la de 720p si éste no existe o si el tamaño es diferente
if folder and folder != '720p':
for root, folders, files in filetools.walk(filetools.join(default, '720p')):
for f in files:
if not filetools.exists(filetools.join(default, folder, f)) or \
(filetools.getsize(filetools.join(default, folder, f)) !=
filetools.getsize(filetools.join(default, '720p', f))):
filetools.copy(filetools.join(default, '720p', f),
filetools.join(default, folder, f),
True)
except:
import traceback
logger.error("Al comprobar o crear la carpeta de resolución")
logger.error(traceback.format_exc())

4
plugin.video.alfa/platformcode/download_and_play.py
View File

@@ -15,8 +15,9 @@ import urllib2
import xbmc
import xbmcgui
from core import config
from core import downloadtools
from platformcode import config, logger
from core import logger
# Download a file and start playing while downloading
@@ -322,7 +323,6 @@ class DownloadThread(threading.Thread):
self.tiempofalta = 0
break
except:
import sys
reintentos = reintentos + 1
logger.info("ERROR en la descarga del bloque, reintento %d" % reintentos)
for line in sys.exc_info():

7
plugin.video.alfa/platformcode/launcher.py
View File

@@ -8,11 +8,12 @@ import sys
import urllib2
from core import channeltools
from core import config
from core import videolibrarytools
from core import logger
from core import scrapertools
from core import servertools
from core import videolibrarytools
from core.item import Item
from platformcode import config, logger
from platformcode import platformtools
@@ -73,7 +74,7 @@ def run(item=None):
# itemlist.insert(0, Item(title="Descargar version " + new_published_version_tag,
# version=new_published_version_tag, channel="updater",
# action="update",
# thumbnail=channelselector.get_thumb("update.png")))
# thumbnail=channelselector.get_thumb("thumb_update.png")))
# except:
# import traceback
# logger.error(traceback.format_exc())

78
plugin.video.alfa/platformcode/logger.py
View File

@@ -1,78 +0,0 @@
# -*- coding: utf-8 -*-
# --------------------------------------------------------------------------------
# Logger (kodi)
# --------------------------------------------------------------------------------
import inspect
import xbmc
from platformcode import config
loggeractive = (config.get_setting("debug") == True)
def log_enable(active):
global loggeractive
loggeractive = active
def encode_log(message=""):
# Unicode to utf8
if type(message) == unicode:
message = message.encode("utf8")
# All encodings to utf8
elif type(message) == str:
message = unicode(message, "utf8", errors="replace").encode("utf8")
# Objects to string
else:
message = str(message)
return message
def get_caller(message=None):
module = inspect.getmodule(inspect.currentframe().f_back.f_back)
module = module.__name__
function = inspect.currentframe().f_back.f_back.f_code.co_name
if module == "__main__":
module = "alfa"
else:
module = "alfa." + module
if message:
if module not in message:
if function == "<module>":
return module + " " + message
else:
return module + " [" + function + "] " + message
else:
return message
else:
if function == "<module>":
return module
else:
return module + "." + function
def info(texto=""):
if loggeractive:
xbmc.log(get_caller(encode_log(texto)), xbmc.LOGNOTICE)
def debug(texto=""):
if loggeractive:
texto = " [" + get_caller() + "] " + encode_log(texto)
xbmc.log("######## DEBUG #########", xbmc.LOGNOTICE)
xbmc.log(texto, xbmc.LOGNOTICE)
def error(texto=""):
texto = " [" + get_caller() + "] " + encode_log(texto)
xbmc.log("######## ERROR #########", xbmc.LOGERROR)
xbmc.log(texto, xbmc.LOGERROR)

4
plugin.video.alfa/platformcode/mct.py
View File

@@ -19,7 +19,7 @@ except Exception, e:
import xbmc
import xbmcgui
from platformcode import config
from core import config
from core import scrapertools
from core import filetools
@@ -497,7 +497,7 @@ def play(url, xlistitem={}, is_view=None, subtitle="", item=None):
def getProgress(h, video_file, _pf={}):
if len(_pf) > 0:
_pf_msg = "[%s] [%s] %s[%s] [%s]" % (
_pf['current'], _pf['continuous'], _pf['continuous2'], _pf['have'], _pf['len'])
_pf['current'], _pf['continuous'], _pf['continuous2'], _pf['have'], _pf['len'])
else:
_pf_msg = ""

4
plugin.video.alfa/platformcode/platformtools.py
View File

@@ -12,12 +12,12 @@ import os
import sys
import urllib
import config
import xbmc
import xbmcgui
import xbmcplugin
from core import config
from core import logger
from core.item import Item
from platformcode import logger
def dialog_ok(heading, line1, line2="", line3=""):

2
plugin.video.alfa/platformcode/recaptcha.py
View File

@@ -1,9 +1,9 @@
# -*- coding: utf-8 -*-
import xbmcgui
from core import config
from core import httptools
from core import scrapertools
from platformcode import config
from platformcode import platformtools

3
plugin.video.alfa/platformcode/subtitletools.py
View File

@@ -8,7 +8,8 @@ from unicodedata import normalize
import xbmc
import xbmcgui
from platformcode import config, logger
from core import config
from core import logger
allchars = string.maketrans('', '')
deletechars = ',\\/:*"<>|?'

17
plugin.video.alfa/platformcode/xbmc_config_menu.py
View File

@@ -8,8 +8,9 @@ import os
import xbmcgui
from core import channeltools
from core import config
from core import logger
from core import servertools
from platformcode import config, logger
class SettingsWindow(xbmcgui.WindowXMLDialog):
@@ -860,16 +861,15 @@ class SettingsWindow(xbmcgui.WindowXMLDialog):
if focus not in [10004, 10005, 10006]:
try:
focus_control = \
[self.visible_controls.index(c) for c in self.visible_controls if
c["control"] == self.getFocus()][
0]
[self.visible_controls.index(c) for c in self.visible_controls if c["control"] == self.getFocus()][
0]
focus_control += 1
except:
focus_control = 0
while not focus_control == len(self.visible_controls) and (
self.visible_controls[focus_control]["type"] == "label" or not
self.visible_controls[focus_control]["active"]):
self.visible_controls[focus_control]["type"] == "label" or not
self.visible_controls[focus_control]["active"]):
focus_control += 1
if focus_control >= len(self.visible_controls):
@@ -884,9 +884,8 @@ class SettingsWindow(xbmcgui.WindowXMLDialog):
if focus not in [10003, 10004, 10005, 10006]:
try:
focus_control = \
[self.visible_controls.index(c) for c in self.visible_controls if
c["control"] == self.getFocus()][
0]
[self.visible_controls.index(c) for c in self.visible_controls if c["control"] == self.getFocus()][
0]
focus_control -= 1
while not focus_control == -1 and (self.visible_controls[focus_control]["type"] == "label" or not

2
plugin.video.alfa/platformcode/xbmc_info_window.py
View File

@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
import xbmcgui
from core import logger
from core.tmdb import Tmdb
from platformcode import logger
ID_BUTTON_CLOSE = 10003
ID_BUTTON_PREVIOUS = 10025

3
plugin.video.alfa/platformcode/xbmc_videolibrary.py
View File

@@ -9,9 +9,10 @@ import time
import urllib2
import xbmc
from core import config
from core import filetools
from core import jsontools
from platformcode import config, logger
from core import logger
from platformcode import platformtools