def overwrite_tools(item):
import library_service
from core import library
seleccion = platformtools.dialog_yesno("Sovrascrivere la libreria?",
"Richiede un certo tempo.",
"Continuare?")
if seleccion == 1:
heading = 'Sovrascrivo la libreria....'
p_dialog = platformtools.dialog_progress_bg('Stefano', heading)
p_dialog.update(0, '')
import glob
show_list = glob.glob(
filetools.join(library.TVSHOWS_PATH, u'/*/tvshow.sod'))
if show_list:
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
head_nfo, serie = library.read_nfo(tvshow_file)
path = filetools.dirname(tvshow_file)
if not serie.active:
# si la serie no esta activa descartar
continue
# Eliminamos la carpeta con la serie ...
filetools.rmdirtree(path)
# ... y la volvemos a añadir
library_service.update(path, p_dialog, i, t, serie, 3)
p_dialog.close()
def actualizaLibreria():
logger.info("")
mantenimientoBD()
# obtener resultados BBDD Kodi
nun_records, records = getBBDDKodi()
# Por cada elemento
heading = config.get_localized_string(30020)
p_dialog = platformtools.dialog_progress_bg("Actualizando", heading)
p_dialog.update(0, '')
if (nun_records != 0):
t = float(100) / nun_records
i = 0
for row in records:
p_dialog.update(int(math.ceil((i + 1) * t)), heading, row[1])
# Obtener id de resultado Kodi
id = getIdFromKodi(row)
if (id == ""):
dict_data = search_themoviedb(row[1])
if (dict_data['total_results'] != 0):
elemento = dict_data['results'][0]
id = str(elemento['id'])
# Buscar datos generales de TMDB con id
dict_data2 = tvshow_tmdb(id)
insertDataBBDD(dict_data2, row, id)
# Insertar datos generales en BBDD
# Insertar datos temporadas en BBDD
# Insertar datos generos en BBDD
i = i + 1
p_dialog.close()
def export_videolibrary(item):
logger.info()
zip_file_folder = platformtools.dialog_browse(3, config.get_localized_string(80002))
if zip_file_folder == "":
return
zip_file = xbmc.translatePath(zip_file_folder + "KoD_video_library-" + str(datetime.date.today()) + ".zip")
p_dialog = platformtools.dialog_progress_bg(config.get_localized_string(20000), config.get_localized_string(80003))
p_dialog.update(0)
if filetools.exists(temp_path):
filetools.rmdirtree(temp_path)
filetools.mkdir(temp_path)
p_dialog.update(25)
filetools.mkdir(movies_path)
copy_tree(videolibrarytools.MOVIES_PATH, movies_path)
p_dialog.update(50)
filetools.mkdir(tvshows_path)
copy_tree(videolibrarytools.TVSHOWS_PATH, tvshows_path)
p_dialog.update(75)
zipper = ziptools.ziptools()
zipper.zip(temp_path, zip_file)
filetools.rmdirtree(temp_path)
p_dialog.update(100)
xbmc.sleep(1000)
p_dialog.close()
platformtools.dialog_notification(config.get_localized_string(20000), config.get_localized_string(80004), time=5000, sound=False)
def overwrite_tools(item):
import library_service
from core import library
seleccion = platformtools.dialog_yesno("Sobrescribir toda la biblioteca",
"Esto puede llevar algun tiempo.",
"¿Desea continuar?")
if seleccion == 1:
heading = 'Sobrescribiendo biblioteca....'
p_dialog = platformtools.dialog_progress_bg('mitvspain', heading)
p_dialog.update(0, '')
import glob
show_list = glob.glob(filetools.join(library.TVSHOWS_PATH, u'/*/tvshow.nfo'))
if show_list:
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
head_nfo, serie = library.read_nfo(tvshow_file)
path = filetools.dirname(tvshow_file)
if not serie.active:
# si la serie no esta activa descartar
continue
# Eliminamos la carpeta con la serie ...
filetools.rmdirtree(path)
# ... y la volvemos a añadir
library_service.update(path, p_dialog, i, t, serie, 3)
p_dialog.close()
def check_for_library_format():
logger.info()
if config.get_setting("library_version") == 'v4':
p_dialog = platformtools.dialog_progress_bg(
"Stream On Demand",
"Conversione della libreria al nuovo formato...")
p_dialog.update(0)
import glob
for filename in glob.glob(filetools.join(library.MOVIES_PATH,
u'/*/*')):
os.rename(filename, filename.replace('.nfo', '.sod'))
p_dialog.update(50)
for filename in glob.glob(filetools.join(library.TVSHOWS_PATH,
u'/*/*')):
os.rename(filename, filename.replace('.nfo', '.sod'))
p_dialog.update(100)
xbmc.sleep(2000)
p_dialog.close()
config.set_setting("library_version", "v5")
return
def update_servers_files(update_servers_list):
# ----------------------------
from platformcode import platformtools
progress = platformtools.dialog_progress_bg("Update servers list")
# ----------------------------
for index, server in enumerate(update_servers_list):
# ----------------------------
percentage = index * 100 / len(update_servers_list)
# ----------------------------
data = scrapertools.cache_page(remote_url + server[0] + ".py")
f = open(os.path.join(local_folder, server[0] + ".py"), 'w')
f.write(data)
f.close()
# ----------------------------
progress.update(percentage, ' Update server: "' + server[0] + '"',
'MD5: "' + server[1] + '"')
# ----------------------------
# ----------------------------
progress.close()
def read_remote_servers_list(local_servers):
data = scrapertools.cache_page(remote_url + "servertools.py")
f = open(os.path.join(local_folder, "servertools.py"), 'w')
f.write(data)
f.close()
all_servers = sorted(
servertools.FREE_SERVERS + \
servertools.PREMIUM_SERVERS + \
servertools.FILENIUM_SERVERS + \
servertools.REALDEBRID_SERVERS + \
servertools.ALLDEBRID_SERVERS
)
servers = []
for server_id in all_servers:
if server_id not in servers:
servers.append(server_id)
# ----------------------------
from platformcode import platformtools
progress = platformtools.dialog_progress_bg("Remote servers list")
# ----------------------------
remote_servers = []
update_servers_list = []
for index, server in enumerate(servers):
# ----------------------------
percentage = index * 100 / len(servers)
# ----------------------------
server_file = urlparse.urljoin(remote_url, server + ".py")
data = scrapertools.cache_page(server_file)
if data != "Not Found":
md5_remote_server = md5_remote(data)
remote_servers.append([server, md5_remote_server])
md5_local_server = local_servers.get(server)
if md5_local_server:
if md5_local_server != md5_remote_server:
update_servers_list.append([
server, md5_remote_server, md5_local_server, "Update"
])
else:
update_servers_list.append(
[server, md5_remote_server, "New", "Update"])
# ----------------------------
progress.update(percentage, ' Remote server: "' + server + '"',
'MD5: "' + md5_remote_server + '"')
# ----------------------------
# ----------------------------
progress.close()
# ----------------------------
return update_servers_list
def play_from_library(item):
"""
Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener
más items, como mucho se puede colocar un dialogo de seleccion.
Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante
"Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas
las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para
la biblioteca.
@type item: item
@param item: elemento con información
"""
logger.info("streamondemand.platformcode.launcher play_from_library")
# logger.debug("item: \n" + item.tostring('\n'))
import xbmcgui
import xbmcplugin
import xbmc
# Intentamos reproducir una imagen (esto no hace nada y ademas no da error)
xbmcplugin.setResolvedUrl(int(sys.argv[1]), True,
xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png")))
# Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion
xbmc.Player().stop()
# modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes
item.action = "findvideos"
# y volvemos a lanzar kodi
if xbmc.getCondVisibility('Window.IsMedia'):
xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")")
else:
from channels import biblioteca
from platformcode import xbmc_library
p_dialog = platformtools.dialog_progress_bg('streamondemand', 'Caricamento in corso...')
p_dialog.update(0, '')
itemlist = biblioteca.findvideos(item)
p_dialog.update(50, '')
if len(itemlist) > 0:
# El usuario elige el mirror
opciones = []
for item in itemlist:
opciones.append(item.title)
seleccion = platformtools.dialog_select(config.get_localized_string(30163), opciones)
if seleccion == -1:
return
item = biblioteca.play(itemlist[seleccion])[0]
p_dialog.update(100, '')
platformtools.play_video(item)
p_dialog.close()
xbmc_library.mark_auto_as_watched(itemlist[seleccion])
def play_from_library(item):
"""
Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener
más items, como mucho se puede colocar un dialogo de seleccion.
Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante
"Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas
las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para
la biblioteca.
@type item: item
@param item: elemento con información
"""
logger.info("pelisalacarta.platformcode.launcher play_from_library")
# logger.debug("item: \n" + item.tostring('\n'))
import xbmcgui
import xbmcplugin
import xbmc
# Intentamos reproducir una imagen (esto no hace nada y ademas no da error)
xbmcplugin.setResolvedUrl(int(sys.argv[1]), True,
xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png")))
# Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion
xbmc.Player().stop()
# modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes
item.action = "findvideos"
# y volvemos a lanzar kodi
if xbmc.getCondVisibility('Window.IsMedia'):
xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")")
else:
from channels import biblioteca
from platformcode import xbmc_library
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', 'Cargando...')
p_dialog.update(0, '')
itemlist = biblioteca.findvideos(item)
p_dialog.update(50, '')
if len(itemlist) > 0:
# El usuario elige el mirror
opciones = []
for item in itemlist:
opciones.append(item.title)
seleccion = platformtools.dialog_select(config.get_localized_string(30163), opciones)
if seleccion == -1:
return
item = biblioteca.play(itemlist[seleccion])[0]
p_dialog.update(100, '')
platformtools.play_video(item)
p_dialog.close()
xbmc_library.mark_auto_as_watched(itemlist[seleccion])
def read_remote_servers_list( local_servers ):
data = scrapertools.cache_page( remote_url + "servertools.py")
f = open( os.path.join( local_folder, "servertools.py" ) ,'w' )
f.write( data )
f.close()
all_servers = sorted(
servertools.FREE_SERVERS + \
servertools.PREMIUM_SERVERS + \
servertools.FILENIUM_SERVERS + \
servertools.REALDEBRID_SERVERS + \
servertools.ALLDEBRID_SERVERS
)
servers = []
for server_id in all_servers:
if server_id not in servers:
servers.append( server_id )
# ----------------------------
from platformcode import platformtools
progress = platformtools.dialog_progress_bg( "Remote servers list" )
# ----------------------------
remote_servers = []
update_servers_list = []
for index, server in enumerate( servers ):
# ----------------------------
percentage = index * 100 / len( servers )
# ----------------------------
server_file = urlparse.urljoin( remote_url, server + ".py" )
data = scrapertools.cache_page( server_file )
if data != "Not Found":
md5_remote_server = md5_remote( data )
remote_servers.append( [ server, md5_remote_server ] )
md5_local_server = local_servers.get( server )
if md5_local_server:
if md5_local_server != md5_remote_server:
update_servers_list.append( [ server, md5_remote_server, md5_local_server, "Update" ] )
else:
update_servers_list.append( [ server, md5_remote_server, "New", "Update" ] )
# ----------------------------
progress.update( percentage, ' Remote server: "' + server + '"', 'MD5: "' + md5_remote_server + '"' )
# ----------------------------
# ----------------------------
progress.close()
# ----------------------------
return update_servers_list
def compartir_lista(item):
logger.info()
fullfilename = os.path.join(config.get_data_path(), item.lista)
if not os.path.exists(fullfilename):
platformtools.dialog_ok('Alfa', 'Error, no se encuentra la lista!', fullfilename)
return False
try:
progreso = platformtools.dialog_progress_bg('Compartir lista', 'Conectando con tinyupload ...')
# Acceso a la página principal de tinyupload para obtener datos necesarios
from core import httptools, scrapertools
data = httptools.downloadpage('http://s000.tinyupload.com/index.php').data
upload_url = scrapertools.find_single_match(data, 'form action="([^"]+)')
sessionid = scrapertools.find_single_match(upload_url, 'sid=(.+)')
progreso.update(10, 'Subiendo fichero', 'Espera unos segundos a que acabe de subirse tu fichero de lista a tinyupload')
# Envío del fichero a tinyupload mediante multipart/form-data
from future import standard_library
standard_library.install_aliases()
from lib import MultipartPostHandler
import urllib.request, urllib.error
opener = urllib.request.build_opener(MultipartPostHandler.MultipartPostHandler)
params = { 'MAX_FILE_SIZE' : '52428800', 'file_description' : '', 'sessionid' : sessionid, 'uploaded_file' : open(fullfilename, 'rb') }
handle = opener.open(upload_url, params)
data = handle.read()
progreso.close()
if not 'File was uploaded successfuly' in data:
logger.debug(data)
platformtools.dialog_ok('Alfa', 'Error, no se ha podido subir el fichero a tinyupload.com!')
return False
codigo = scrapertools.find_single_match(data, 'href="index\.php\?file_id=([^"]+)')
except:
platformtools.dialog_ok('Alfa', 'Error, al intentar subir el fichero a tinyupload.com!', item.lista)
return False
# Apuntar código en fichero de log y dentro de la lista
save_log_lista_shared('Subido fichero %s a tinyupload.com. El código para descargarlo es: %s' % (item.lista, codigo))
alfav = AlfavoritesData(item.lista)
alfav.info_lista['tinyupload_date'] = fechahora_actual()
alfav.info_lista['tinyupload_code'] = codigo
alfav.save()
platformtools.dialog_ok('Alfa', 'Subida lista a tinyupload. Si quieres compartirla con alguien, pásale este código:', codigo)
return True
def compartir_lista(item):
logger.debug()
fullfilename = os.path.join(config.get_data_path(), item.lista)
if not os.path.exists(fullfilename):
platformtools.dialog_ok('KoD', config.get_localized_string(70630) + '\n' + fullfilename)
return False
try:
progreso = platformtools.dialog_progress_bg(config.get_localized_string(70643), config.get_localized_string(70644))
# Access to the tinyupload home page to obtain necessary data
from core import httptools, scrapertools
data = httptools.downloadpage('http://s000.tinyupload.com/index.php').data
upload_url = scrapertools.find_single_match(data, 'form action="([^"]+)')
sessionid = scrapertools.find_single_match(upload_url, 'sid=(.+)')
progreso.update(10, config.get_localized_string(70645) + '\n' + config.get_localized_string(70646))
# Sending the file to tinyupload using multipart / form-data
from future import standard_library
standard_library.install_aliases()
from lib import MultipartPostHandler
import urllib.request, urllib.error
opener = urllib.request.build_opener(MultipartPostHandler.MultipartPostHandler)
params = { 'MAX_FILE_SIZE' : '52428800', 'file_description' : '', 'sessionid' : sessionid, 'uploaded_file' : open(fullfilename, 'rb') }
handle = opener.open(upload_url, params)
data = handle.read()
progreso.close()
if not 'File was uploaded successfuly' in data:
logger.debug(data)
platformtools.dialog_ok('KoD', config.get_localized_string(70647))
return False
codigo = scrapertools.find_single_match(data, 'href="index\.php\?file_id=([^"]+)')
except:
platformtools.dialog_ok('KoD', config.get_localized_string(70647) + '\n' + item.lista)
return False
# Point code in log file and inside the list
save_log_lista_shared(config.get_localized_string(70648) + ' ' + item.lista + ' ' + codigo + ' ' + config.get_localized_string(70649))
alfav = KodfavouritesData(item.lista)
alfav.info_lista['tinyupload_date'] = fechahora_actual()
alfav.info_lista['tinyupload_code'] = codigo
alfav.save()
platformtools.dialog_ok('KoD', config.get_localized_string(70650) + '\n' + codigo)
return True
def update_serie(item):
logger.info()
#logger.debug("item:\n" + item.tostring('\n'))
heading = 'Actualizando serie....'
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', heading)
p_dialog.update(0, heading, item.contentSerieName)
import library_service
if library_service.update(item.path, p_dialog, 1, 1, item, False) and config.is_xbmc():
library.update(folder=filetools.basename(item.path))
p_dialog.close()
def import_videolibrary(item):
logger.info()
zip_file = platformtools.dialog_browse(1,
config.get_localized_string(80005))
if zip_file == "":
return
if not platformtools.dialog_yesno(config.get_localized_string(20000),
config.get_localized_string(80006)):
return
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(20000), config.get_localized_string(80007))
p_dialog.update(0)
if filetools.exists(temp_path):
filetools.rmdirtree(temp_path)
filetools.mkdir(temp_path)
unzipper = ziptools.ziptools()
unzipper.extract(zip_file, temp_path)
p_dialog.update(25)
filetools.rmdirtree(videolibrarytools.VIDEOLIBRARY_PATH)
p_dialog.update(50)
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc.sleep(5000)
xbmc_videolibrary.clean()
config.verify_directories_created()
if filetools.exists(movies_path):
copy_tree(movies_path, videolibrarytools.MOVIES_PATH)
p_dialog.update(70)
if filetools.exists(tvshows_path):
copy_tree(tvshows_path, videolibrarytools.TVSHOWS_PATH)
p_dialog.update(90)
filetools.rmdirtree(temp_path)
p_dialog.update(100)
xbmc.sleep(2000)
p_dialog.close()
platformtools.dialog_ok(config.get_localized_string(20000),
config.get_localized_string(80008))
if platformtools.dialog_yesno(config.get_localized_string(20000),
config.get_localized_string(80009)):
import service
service.check_for_update(overwrite=True)
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc_videolibrary.update()
def import_videolibrary(item):
logger.info()
zip_file = unicode(
platformtools.dialog_browse(1,
config.get_localized_string(80005),
mask=".zip"))
if zip_file == "":
return
if not platformtools.dialog_yesno(config.get_localized_string(20000),
config.get_localized_string(80006)):
return
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(20000), config.get_localized_string(80007))
# p_dialog.update(0)
if filetools.exists(temp_path):
shutil.rmtree(temp_path)
filetools.mkdir(videolibrary_temp_path)
unzip(videolibrary_temp_path, zip_file)
p_dialog.update(20)
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc_videolibrary.clean()
p_dialog.update(30)
shutil.rmtree(videolibrary_movies_path)
shutil.rmtree(videolibrary_tvshows_path)
p_dialog.update(50)
config.verify_directories_created()
if filetools.exists(movies_path):
copy_tree(movies_path, videolibrary_movies_path)
p_dialog.update(70)
if filetools.exists(tvshows_path):
copy_tree(tvshows_path, videolibrary_tvshows_path)
p_dialog.update(90)
shutil.rmtree(temp_path)
p_dialog.update(100)
xbmc.sleep(1000)
p_dialog.close()
platformtools.dialog_notification(config.get_localized_string(20000),
config.get_localized_string(80008),
time=5000,
sound=False)
videolibrary.update_videolibrary()
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc_videolibrary.update()
def update_serie(item):
logger.info()
#logger.debug("item:\n" + item.tostring('\n'))
heading = 'Aggiornamento serie....'
p_dialog = platformtools.dialog_progress_bg('streamondemand', heading)
p_dialog.update(0, heading, item.contentSerieName)
import library_service
if library_service.update(item.path, p_dialog, 1, 1, item, False) and config.is_xbmc():
from platformcode import xbmc_library
xbmc_library.update(folder=filetools.basename(item.path))
p_dialog.close()
def update_tvshow(item):
logger.info()
# logger.debug("item:\n" + item.tostring('\n'))
heading = 'Actualizando serie....'
p_dialog = platformtools.dialog_progress_bg('alfa', heading)
p_dialog.update(0, heading, item.contentSerieName)
import videolibrary_service
if videolibrary_service.update(item.path, p_dialog, 1, 1, item, False) and config.is_xbmc():
from platformcode import xbmc_videolibrary
xbmc_videolibrary.update(folder=filetools.basename(item.path))
p_dialog.close()
def update_serie(item):
logger.info()
# logger.debug("item:\n" + item.tostring('\n'))
heading = 'Aggiornamento serie....'
p_dialog = platformtools.dialog_progress_bg('streamondemand', heading)
p_dialog.update(0, heading, item.contentSerieName)
import library_service
if library_service.update(item.path, p_dialog, 1, 1, item, False) and config.is_xbmc():
from platformcode import xbmc_library
xbmc_library.update(folder=filetools.basename(item.path))
p_dialog.close()
def start_dialog(self, title=config.get_localized_string(60200)):
from platformcode import platformtools
progreso = platformtools.dialog_progress_bg(title, config.get_localized_string(60201))
try:
self.start()
while self.state == self.states.downloading:
time.sleep(0.2)
line1 = "%s" % (self.filename)
line2 = config.get_localized_string(59983) % ( self.downloaded[1], self.downloaded[2], self.size[1], self.size[2], self.speed[1], self.speed[2], self.connections[0], self.connections[1])
line3 = config.get_localized_string(60202) % (self.remaining_time)
progreso.update(int(self.progress), line1, line2 + " " + line3)
self.__update_json()
finally:
progreso.close()
def updateFromZip():
dp = platformtools.dialog_progress_bg('Kodi on Demand', 'Installazione in corso...')
dp.update(0)
remotefilename = 'https://github.com/' + user + "/" + repo + "/archive/" + branch + ".zip"
localfilename = (xbmc.translatePath("special://home/addons/") + "plugin.video.kod.update.zip").encode('utf-8')
destpathname = xbmc.translatePath("special://home/addons/")
logger.info("remotefilename=%s" % remotefilename)
logger.info("localfilename=%s" % localfilename)
# pulizia preliminare
remove(localfilename)
removeTree(destpathname + "addon-" + branch)
import urllib
urllib.urlretrieve(remotefilename, localfilename,
lambda nb, bs, fs, url=remotefilename: _pbhook(nb, bs, fs, url, dp))
# Lo descomprime
logger.info("decompressione...")
logger.info("destpathname=%s" % destpathname)
try:
hash = fixZipGetHash(localfilename)
unzipper = ziptools()
unzipper.extract(localfilename, destpathname)
except Exception as e:
logger.info('Non sono riuscito ad estrarre il file zip')
logger.info(e)
return False
dp.update(95)
# puliamo tutto
removeTree(addonDir)
rename(destpathname + "addon-" + branch, addonDir)
logger.info("Cancellando il file zip...")
remove(localfilename)
dp.update(100)
dp.close()
xbmc.executebuiltin("UpdateLocalAddons")
return hash
def import_videolibrary(item):
logger.info()
zip_file = platformtools.dialog_browse(1, config.get_localized_string(80005))
if zip_file == "":
return
if not platformtools.dialog_yesno(config.get_localized_string(20000), config.get_localized_string(80006)):
return
p_dialog = platformtools.dialog_progress_bg(config.get_localized_string(20000), config.get_localized_string(80007))
p_dialog.update(0)
if filetools.exists(temp_path):
filetools.rmdirtree(temp_path)
filetools.mkdir(temp_path)
unzipper = ziptools.ziptools()
unzipper.extract(zip_file, temp_path)
p_dialog.update(20)
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc_videolibrary.clean()
p_dialog.update(30)
filetools.rmdirtree(videolibrarytools.MOVIES_PATH)
filetools.rmdirtree(videolibrarytools.TVSHOWS_PATH)
p_dialog.update(50)
config.verify_directories_created()
if filetools.exists(movies_path):
copy_tree(movies_path, videolibrarytools.MOVIES_PATH)
p_dialog.update(70)
if filetools.exists(tvshows_path):
copy_tree(tvshows_path, videolibrarytools.TVSHOWS_PATH)
p_dialog.update(90)
filetools.rmdirtree(temp_path)
p_dialog.update(100)
xbmc.sleep(1000)
p_dialog.close()
platformtools.dialog_notification(config.get_localized_string(20000), config.get_localized_string(80008), time=5000, sound=False)
videolibrary.update_videolibrary()
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc_videolibrary.update()
def findvideos(item, itemlist=[]):
if not itemlist:
logger.debug('Executing channel', item.channel, 'method', item.action)
channel = importChannel(item)
from core import servertools
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(20000),
config.get_localized_string(60683))
p_dialog.update(0)
try:
# First checks if channel has a "findvideos" function
if hasattr(channel, 'findvideos'):
itemlist = getattr(channel, item.action)(item)
# If not, uses the generic findvideos function
else:
logger.debug(
'No channel "findvideos" method, executing core method')
itemlist = servertools.find_video_items(item)
itemlist = limitItemlist(itemlist)
except Exception as ex:
template = "An exception of type %s occured. Arguments:\n%r"
message = template % (type(ex).__name__, ex.args)
logger.error(" %s" % message)
p_dialog.update(100)
p_dialog.close()
serverlist = [s for s in itemlist if s.server]
if itemlist and not serverlist:
platformtools.render_items(itemlist, item)
if not serverlist:
platformtools.dialog_notification(config.get_localized_string(20000),
config.get_localized_string(60347))
elif len(serverlist) == 1:
# If there is only one server play it immediately
play(itemlist[0].clone(no_return=True))
else:
platformtools.serverWindow(item, itemlist)
def read_local_servers_list():
all_servers = sorted(
servertools.FREE_SERVERS + \
servertools.PREMIUM_SERVERS + \
servertools.FILENIUM_SERVERS + \
servertools.REALDEBRID_SERVERS + \
servertools.ALLDEBRID_SERVERS
)
servers = []
for server_id in all_servers:
if server_id not in servers:
servers.append(server_id)
# ----------------------------
from platformcode import platformtools
progress = platformtools.dialog_progress_bg("Local servers list")
# ----------------------------
local_servers = []
for index, server in enumerate(servers):
# ----------------------------
percentage = index * 100 / len(servers)
# ----------------------------
server_file = os.path.join(config.get_runtime_path(), "servers",
server + ".py")
if os.path.exists(server_file):
md5_local_server = md5_local(server_file)
local_servers.append([server, md5_local_server])
# ----------------------------
progress.update(percentage, ' Local server: "' + server + '"',
'MD5: "' + md5_local_server + '"')
# ----------------------------
# ----------------------------
progress.close()
# ----------------------------
return local_servers
def read_local_servers_list():
all_servers = sorted(
servertools.FREE_SERVERS + \
servertools.PREMIUM_SERVERS + \
servertools.FILENIUM_SERVERS + \
servertools.REALDEBRID_SERVERS + \
servertools.ALLDEBRID_SERVERS
)
servers = []
for server_id in all_servers:
if server_id not in servers:
servers.append( server_id )
# ----------------------------
from platformcode import platformtools
progress = platformtools.dialog_progress_bg( "Local servers list" )
# ----------------------------
local_servers = []
for index, server in enumerate( servers ):
# ----------------------------
percentage = index * 100 / len( servers )
# ----------------------------
server_file = os.path.join( config.get_runtime_path(), "servers", server + ".py" )
if os.path.exists( server_file ):
md5_local_server = md5_local( server_file )
local_servers.append( [ server, md5_local_server ] )
# ----------------------------
progress.update( percentage, ' Local server: "' + server + '"', 'MD5: "' + md5_local_server + '"' )
# ----------------------------
# ----------------------------
progress.close()
# ----------------------------
return local_servers
def update_tvshow(item):
logger.info()
# logger.debug("item:\n" + item.tostring('\n'))
heading = config.get_localized_string(60037)
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(20000), heading)
p_dialog.update(0, heading, item.contentSerieName)
import videolibrary_service
if videolibrary_service.update(item.path, p_dialog, 1, 1, item,
False) and config.is_xbmc():
from platformcode import xbmc_videolibrary
xbmc_videolibrary.update(folder=filetools.basename(item.path))
p_dialog.close()
for channel, url in list(item.library_urls.items()):
channel_f = generictools.verify_channel(channel)
if config.get_setting('auto_download_new', channel_f):
from channels import downloads
downloads.download_auto(item)
break
def delete_videolibrary(item):
logger.info()
if not platformtools.dialog_yesno(config.get_localized_string(20000), config.get_localized_string(80037)):
return
p_dialog = platformtools.dialog_progress_bg(config.get_localized_string(20000), config.get_localized_string(80038))
p_dialog.update(0)
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
from platformcode import xbmc_videolibrary
xbmc_videolibrary.clean()
p_dialog.update(10)
filetools.rmdirtree(videolibrarytools.MOVIES_PATH)
p_dialog.update(50)
filetools.rmdirtree(videolibrarytools.TVSHOWS_PATH)
p_dialog.update(90)
config.verify_directories_created()
p_dialog.update(100)
xbmc.sleep(1000)
p_dialog.close()
platformtools.dialog_notification(config.get_localized_string(20000), config.get_localized_string(80039), time=5000, sound=False)
def overwrite_tools(item):
import library_service
from core import library
seleccion = platformtools.dialog_yesno("Sobrescribir toda la biblioteca",
"Esto puede llevar algun tiempo.",
"¿Desea continuar?")
if seleccion == 1:
heading = 'Sobrescribiendo biblioteca....'
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', heading)
p_dialog.update(0, '')
show_list = []
for path, folders, files in filetools.walk(library.TVSHOWS_PATH):
show_list.extend([filetools.join(path, f) for f in files if f == "tvshow.nfo"])
if show_list:
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
head_nfo, serie = library.read_nfo(tvshow_file)
path = filetools.dirname(tvshow_file)
if not serie.active:
# si la serie no esta activa descartar
continue
# Eliminamos la carpeta con la serie ...
filetools.rmdirtree(path)
# ... y la volvemos a añadir
library_service.update(path, p_dialog, i, t, serie, 3)
p_dialog.close()
def update_servers_files( update_servers_list ):
# ----------------------------
from platformcode import platformtools
progress = platformtools.dialog_progress_bg( "Update servers list" )
# ----------------------------
for index, server in enumerate( update_servers_list ):
# ----------------------------
percentage = index * 100 / len( update_servers_list )
# ----------------------------
data = scrapertools.cache_page( remote_url + server[0] + ".py" )
f = open( os.path.join( local_folder, server[0] + ".py" ) ,'w' )
f.write( data )
f.close()
# ----------------------------
progress.update( percentage, ' Update server: "' + server[0] + '"', 'MD5: "' + server[1] + '"' )
# ----------------------------
# ----------------------------
progress.close()
def update_tvshow(item):
logger.info()
# logger.debug("item:\n" + item.tostring('\n'))
heading = config.get_localized_string(60037)
p_dialog = platformtools.dialog_progress_bg(config.get_localized_string(20000), heading)
p_dialog.update(0, heading, item.contentSerieName)
import service
if service.update(item.path, p_dialog, 0, 100, item, False) and config.is_xbmc() and config.get_setting("videolibrary_kodi"):
from platformcode import xbmc_videolibrary
xbmc_videolibrary.update(folder=filetools.basename(item.path))
p_dialog.close()
# check if the TV show is ended or has been canceled and ask the user to remove it from the video library update
nfo_path = filetools.join(item.path, "tvshow.nfo")
head_nfo, item_nfo = videolibrarytools.read_nfo(nfo_path)
if item.active and not item_nfo.active:
# if not platformtools.dialog_yesno(config.get_localized_string(60037).replace('...',''), config.get_localized_string(70268) % item.contentSerieName):
item_nfo.active = 1
filetools.write(nfo_path, head_nfo + item_nfo.tojson())
platformtools.itemlist_refresh()
def move_videolibrary(current_path, new_path, current_movies_folder, new_movies_folder, current_tvshows_folder, new_tvshows_folder):
logger.info()
backup_current_path = current_path
backup_new_path = new_path
logger.info('current_path: ' + current_path)
logger.info('new_path: ' + new_path)
logger.info('current_movies_folder: ' + current_movies_folder)
logger.info('new_movies_folder: ' + new_movies_folder)
logger.info('current_tvshows_folder: ' + current_tvshows_folder)
logger.info('new_tvshows_folder: ' + new_tvshows_folder)
notify = False
progress = platformtools.dialog_progress_bg(config.get_localized_string(20000), config.get_localized_string(80011))
current_path = u'' + xbmc.translatePath(current_path)
new_path = u'' + xbmc.translatePath(new_path)
current_movies_path = u'' + filetools.join(current_path, current_movies_folder)
new_movies_path = u'' + filetools.join(new_path, new_movies_folder)
current_tvshows_path = u'' + filetools.join(current_path, current_tvshows_folder)
new_tvshows_path = u'' + filetools.join(new_path, new_tvshows_folder)
logger.info('current_movies_path: ' + current_movies_path)
logger.info('new_movies_path: ' + new_movies_path)
logger.info('current_tvshows_path: ' + current_tvshows_path)
logger.info('new_tvshows_path: ' + new_tvshows_path)
from platformcode import xbmc_videolibrary
movies_path, tvshows_path = xbmc_videolibrary.check_sources(new_movies_path, new_tvshows_path)
logger.info('check_sources: ' + str(movies_path) + ', ' + str(tvshows_path))
if movies_path or tvshows_path:
if not movies_path:
filetools.rmdir(new_movies_path)
if not tvshows_path:
filetools.rmdir(new_tvshows_path)
config.set_setting("videolibrarypath", backup_current_path)
config.set_setting("folder_movies", current_movies_folder)
config.set_setting("folder_tvshows", current_tvshows_folder)
xbmc_videolibrary.update_sources(backup_current_path, backup_new_path)
progress.update(100)
xbmc.sleep(1000)
progress.close()
platformtools.dialog_ok(config.get_localized_string(20000), config.get_localized_string(80028))
return
config.verify_directories_created()
progress.update(10, config.get_localized_string(20000) + '\n' + config.get_localized_string(80012))
if current_movies_path != new_movies_path:
if filetools.listdir(current_movies_path):
dir_util.copy_tree(current_movies_path, new_movies_path)
notify = True
filetools.rmdirtree(current_movies_path)
progress.update(40)
if current_tvshows_path != new_tvshows_path:
if filetools.listdir(current_tvshows_path):
dir_util.copy_tree(current_tvshows_path, new_tvshows_path)
notify = True
filetools.rmdirtree(current_tvshows_path)
progress.update(70)
if current_path != new_path and not filetools.listdir(current_path) and not "plugin.video.kod\\videolibrary" in current_path:
filetools.rmdirtree(current_path)
xbmc_videolibrary.update_sources(backup_new_path, backup_current_path)
if config.is_xbmc() and config.get_setting("videolibrary_kodi"):
xbmc_videolibrary.update_db(backup_current_path, backup_new_path, current_movies_folder, new_movies_folder, current_tvshows_folder, new_tvshows_folder, progress)
else:
progress.update(100)
xbmc.sleep(1000)
progress.close()
if notify:
platformtools.dialog_notification(config.get_localized_string(20000), config.get_localized_string(80014), time=5000, sound=False)
def do_channels_search(item):
logger.info("streamondemand.channels.buscadorall do_channels_search")
tecleado, category, title_year = item.extra.split('{}')
try:
title_year = int(title_year)
except:
title_year = 0
itemlist = []
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("streamondemand.channels.buscador channels_path=" + channels_path)
channel_language = config.get_setting("channel_language")
logger.info("streamondemand.channels.buscador channel_language=" + channel_language)
if channel_language == "":
channel_language = "all"
logger.info("streamondemand.channels.buscador channel_language=" + channel_language)
progreso = platformtools.dialog_progress_bg(NLS_Looking_For % tecleado)
channel_files = glob.glob(channels_path)
search_results = Queue.Queue()
number_of_channels = 0
for infile in channel_files:
basename_without_extension = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(basename_without_extension)
# No busca si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# En caso de busqueda por categorias
if category and category not in channel_parameters["categories"]:
continue
# No busca si es un canal para adultos, y el modo adulto está desactivado
if channel_parameters["adult"] == "true" and config.get_setting("adult_mode") == "false":
continue
# No busca si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# No busca si es un canal excluido de la busqueda global
include_in_global_search = channel_parameters["include_in_global_search"]
if include_in_global_search == "":
# Buscar en la configuracion del canal
include_in_global_search = str(config.get_setting("include_in_global_search", basename_without_extension))
if include_in_global_search.lower() != "true":
continue
t = Thread(target=channel_search, args=[search_results, channel_parameters, category, title_year, tecleado])
t.setDaemon(True)
t.start()
number_of_channels += 1
start_time = int(time.time())
completed_channels = 0
while completed_channels < number_of_channels:
delta_time = int(time.time()) - start_time
if len(itemlist) <= 0:
timeout = None # No result so far,lets the thread to continue working until a result is returned
elif delta_time >= TIMEOUT_TOTAL:
break # At least a result matching the searched title has been found, lets stop the search
else:
timeout = TIMEOUT_TOTAL - delta_time # Still time to gather other results
progreso.update(completed_channels * 100 / number_of_channels)
try:
itemlist.extend(search_results.get(timeout=timeout))
completed_channels += 1
except:
# Expired timeout raise an exception
break
progreso.close()
itemlist = sorted(itemlist, key=lambda item: item.fulltitle)
return itemlist
def do_search(item):
logger.info("streamondemand.channels.buscador do_search")
if '{}' in item.extra:
tecleado, category = item.extra.split('{}')
else:
tecleado = item.extra
category = ""
itemlist = []
channels_path = os.path.join(config.get_runtime_path(), "channels",
'*.xml')
logger.info("streamondemand.channels.buscador channels_path=" +
channels_path)
channel_language = config.get_setting("channel_language")
logger.info("streamondemand.channels.buscador channel_language=" +
channel_language)
if channel_language == "":
channel_language = "all"
logger.info("streamondemand.channels.buscador channel_language=" +
channel_language)
progreso = platformtools.dialog_progress_bg(
"Cercando " + urllib.unquote_plus(tecleado), "")
channel_files = sorted(glob.glob(channels_path))
number_of_channels = 0
completed_channels = 0
search_results = Queue.Queue()
start_time = int(time.time())
for infile in channel_files:
basename_without_extension = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(
basename_without_extension)
# Ignore inactive channel
if channel_parameters["active"] != True:
continue
# In case of search by categories
if category and category not in channel_parameters["categories"]:
continue
# Ignore channel filtered by language
if channel_language != "all" and channel_parameters[
"language"] != channel_language:
continue
# Ignore channel not configured in global search
include_in_global_search = channel_parameters[
"include_in_global_search"]
if include_in_global_search == True:
# Search in the channel configuration
include_in_global_search = config.get_setting(
"include_in_global_search", basename_without_extension)
if include_in_global_search == False:
continue
t = Thread(
target=channel_search,
args=[search_results, channel_parameters, category, tecleado])
t.setDaemon(True)
t.start()
number_of_channels += 1
while threading.active_count() >= MAX_THREADS:
delta_time = int(time.time()) - start_time
if len(itemlist) <= 0:
timeout = None # No result so far,lets the thread to continue working until a result is returned
elif delta_time >= TIMEOUT_TOTAL:
progreso.close()
itemlist = sorted(itemlist, key=lambda item: item.fulltitle)
return itemlist
else:
timeout = TIMEOUT_TOTAL - delta_time # Still time to gather other results
progreso.update(completed_channels * 100 / number_of_channels)
try:
itemlist.extend(search_results.get(timeout=timeout))
completed_channels += 1
except:
progreso.close()
itemlist = sorted(itemlist, key=lambda item: item.fulltitle)
return itemlist
while completed_channels < number_of_channels:
delta_time = int(time.time()) - start_time
if len(itemlist) <= 0:
timeout = None # No result so far,lets the thread to continue working until a result is returned
elif delta_time >= TIMEOUT_TOTAL:
break # At least a result matching the searched title has been found, lets stop the search
else:
timeout = TIMEOUT_TOTAL - delta_time # Still time to gather other results
progreso.update(completed_channels * 100 / number_of_channels)
try:
itemlist.extend(search_results.get(timeout=timeout))
completed_channels += 1
except:
# Expired timeout raise an exception
break
progreso.close()
itemlist = sorted(itemlist, key=lambda item: item.fulltitle)
return itemlist
def check_for_update(overwrite=True):
logger.info("Actualizando series...")
p_dialog = None
serie_actualizada = False
update_when_finished = False
hoy = datetime.date.today()
try:
if config.get_setting("updatelibrary", "biblioteca") != 0 or overwrite:
config.set_setting("updatelibrary_last_check", hoy.strftime('%Y-%m-%d'), "biblioteca")
heading = 'Actualizando biblioteca....'
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', heading)
p_dialog.update(0, '')
show_list = []
for path, folders, files in filetools.walk(library.TVSHOWS_PATH):
show_list.extend([filetools.join(path, f) for f in files if f == "tvshow.nfo"])
if show_list:
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
head_nfo, serie = library.read_nfo(tvshow_file)
path = filetools.dirname(tvshow_file)
logger.info("serie=" + serie.contentSerieName)
p_dialog.update(int(math.ceil((i+1) * t)), heading, serie.contentSerieName)
interval = int(serie.active) # Podria ser del tipo bool
if not serie.active:
# si la serie no esta activa descartar
continue
# obtenemos las fecha de actualizacion y de la proxima programada para esta serie
update_next = serie.update_next
if update_next:
y, m, d = update_next.split('-')
update_next = datetime.date(int(y), int(m), int(d))
else:
update_next = hoy
update_last = serie.update_last
if update_last:
y, m, d = update_last.split('-')
update_last = datetime.date(int(y), int(m), int(d))
else:
update_last = hoy
# si la serie esta activa ...
if overwrite or config.get_setting("updatetvshows_interval", "biblioteca") == 0:
# ... forzar actualizacion independientemente del intervalo
serie_actualizada = update(path, p_dialog, i, t, serie, overwrite)
elif interval == 1 and update_next <= hoy:
# ...actualizacion diaria
serie_actualizada = update(path, p_dialog, i, t, serie, overwrite)
if not serie_actualizada and update_last <= hoy - datetime.timedelta(days=7):
# si hace una semana q no se actualiza, pasar el intervalo a semanal
interval = 7
update_next = hoy + datetime.timedelta(days=interval)
elif interval == 7 and update_next <= hoy:
# ...actualizacion semanal
serie_actualizada = update(path, p_dialog, i, t, serie, overwrite)
if not serie_actualizada:
if update_last <= hoy - datetime.timedelta(days=14):
# si hace 2 semanas q no se actualiza, pasar el intervalo a mensual
interval = 30
update_next += datetime.timedelta(days=interval)
elif interval == 30 and update_next <= hoy:
# ...actualizacion mensual
serie_actualizada = update(path, p_dialog, i, t, serie, overwrite)
if not serie_actualizada:
update_next += datetime.timedelta(days=interval)
if interval != int(serie.active) or update_next.strftime('%Y-%m-%d') != serie.update_next:
serie.active = interval
serie.update_next = update_next.strftime('%Y-%m-%d')
serie.channel = "biblioteca"
serie.action = "get_temporadas"
filetools.write(tvshow_file, head_nfo + serie.tojson())
if serie_actualizada:
if config.get_setting("search_new_content", "biblioteca") == 0:
# Actualizamos la biblioteca de Kodi: Buscar contenido en la carpeta de la serie
if config.is_xbmc():
from platformcode import xbmc_library
xbmc_library.update(folder=filetools.basename(path))
else:
update_when_finished = True
if config.get_setting("search_new_content", "biblioteca") == 1 and update_when_finished:
# Actualizamos la biblioteca de Kodi: Buscar contenido en todas las series
if config.is_xbmc():
from platformcode import xbmc_library
xbmc_library.update()
p_dialog.close()
else:
logger.info("No actualiza la biblioteca, está desactivado en la configuración de pelisalacarta")
except Exception as ex:
logger.error("Se ha producido un error al actualizar las series")
template = "An exception of type %s occured. Arguments:\n%r"
message = template % (type(ex).__name__, ex.args)
logger.error(message)
if p_dialog:
p_dialog.close()
def main():
logger.info("pelisalacarta.library_service Actualizando series...")
p_dialog = None
try:
if config.get_setting("updatelibrary") == "true":
heading = 'Actualizando biblioteca....'
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', heading)
p_dialog.update(0, '')
show_list = []
for path, folders, files in filetools.walk(library.TVSHOWS_PATH):
show_list.extend([filetools.join(path, f) for f in files if f == "tvshow.json"])
# fix float porque la division se hace mal en python 2.x
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
serie = Item().fromjson(filetools.read(tvshow_file))
path = filetools.dirname(tvshow_file)
logger.info("pelisalacarta.library_service serie="+serie.contentSerieName)
logger.info("pelisalacarta.library_service Actualizando " + path)
logger.info("pelisalacarta.library_service url " + serie.url)
show_name = serie.contentTitle
if show_name == "":
show_name = serie.show
p_dialog.update(int(math.ceil((i+1) * t)), heading, show_name)
# si la serie esta activa se actualiza
if serie.active:
try:
pathchannels = filetools.join(config.get_runtime_path(), "channels", serie.channel + '.py')
logger.info("pelisalacarta.library_service Cargando canal: " + pathchannels + " " +
serie.channel)
obj = imp.load_source(serie.channel, pathchannels)
itemlist = obj.episodios(serie)
try:
library.save_library_episodes(path, itemlist, serie, True)
except Exception as ex:
logger.info("pelisalacarta.library_service Error al guardar los capitulos de la serie")
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
except Exception as ex:
logger.error("Error al obtener los episodios de: {0}".
format(serie.show))
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
p_dialog.close()
else:
logger.info("No actualiza la biblioteca, está desactivado en la configuración de pelisalacarta")
except Exception as ex:
logger.info("pelisalacarta.library_service Se ha producido un error al actualizar las series")
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
if p_dialog:
p_dialog.close()
def play_from_library(item):
"""
Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener
más items, como mucho se puede colocar un dialogo de seleccion.
Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante
"Container.Update()" cargamos el strm como si un item desde dentro del addon se tratara, quitando todas
las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para
la videoteca.
@type item: item
@param item: elemento con información
"""
logger.info()
# logger.debug("item: \n" + item.tostring('\n'))
import xbmcgui
import xbmcplugin
import xbmc
# Intentamos reproducir una imagen (esto no hace nada y ademas no da error)
xbmcplugin.setResolvedUrl(
int(sys.argv[1]), True,
xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(),
"resources", "subtitle.mp4")))
# Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion
xbmc.Player().stop()
# modificamos el action (actualmente la videoteca necesita "findvideos" ya que es donde se buscan las fuentes
item.action = "findvideos"
window_type = config.get_setting("window_type", "videolibrary")
# y volvemos a lanzar kodi
if xbmc.getCondVisibility('Window.IsMedia') and not window_type == 1:
# Ventana convencional
xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" +
item.tourl() + ")")
else:
# Ventana emergente
from channels import videolibrary
p_dialog = platformtools.dialog_progress_bg('alfa', 'Cargando...')
p_dialog.update(0, '')
itemlist = videolibrary.findvideos(item)
while platformtools.is_playing():
# Ventana convencional
from time import sleep
sleep(5)
p_dialog.update(50, '')
'''# Se filtran los enlaces segun la lista negra
if config.get_setting('filter_servers', "servers"):
itemlist = servertools.filter_servers(itemlist)'''
# Se limita la cantidad de enlaces a mostrar
if config.get_setting("max_links", "videolibrary") != 0:
itemlist = limit_itemlist(itemlist)
# Se "limpia" ligeramente la lista de enlaces
if config.get_setting("replace_VD", "videolibrary") == 1:
itemlist = reorder_itemlist(itemlist)
p_dialog.update(100, '')
xbmc.sleep(500)
p_dialog.close()
if len(itemlist) > 0:
# El usuario elige el mirror
opciones = []
for item in itemlist:
opciones.append(item.title)
# Se abre la ventana de seleccion
if (item.contentSerieName != "" and item.contentSeason != ""
and item.contentEpisodeNumber != ""):
cabecera = ("%s - %sx%s -- %s" %
(item.contentSerieName, item.contentSeason,
item.contentEpisodeNumber,
config.get_localized_string(30163)))
else:
cabecera = config.get_localized_string(30163)
seleccion = platformtools.dialog_select(cabecera, opciones)
if seleccion == -1:
return
else:
item = videolibrary.play(itemlist[seleccion])[0]
platformtools.play_video(item)
def main(overwrite=True):
logger.info("pelisalacarta.library_service Actualizando series...")
p_dialog = None
try:
if config.get_setting("updatelibrary") == "true":
if not overwrite: # No venimos del canal configuracion
updatelibrary_wait = [0, 10000, 20000, 30000, 60000]
wait = updatelibrary_wait[int(config.get_setting("updatelibrary_wait"))]
if wait > 0:
import xbmc
xbmc.sleep(wait)
heading = 'Actualizando biblioteca....'
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', heading)
p_dialog.update(0, '')
show_list = []
for path, folders, files in filetools.walk(library.TVSHOWS_PATH):
show_list.extend([filetools.join(path, f) for f in files if f == "tvshow.nfo"])
# fix float porque la division se hace mal en python 2.x
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
serie = Item().fromjson(filetools.read(tvshow_file, 1))
path = filetools.dirname(tvshow_file)
logger.info("pelisalacarta.library_service serie=" + serie.contentSerieName)
p_dialog.update(int(math.ceil((i+1) * t)), heading, serie.contentSerieName)
if not serie.active:
continue
# si la serie esta activa se actualiza
logger.info("pelisalacarta.library_service Actualizando " + path)
# logger.debug("%s: %s" %(serie.contentSerieName,str(list_canales) ))
for channel, url in serie.library_urls.items():
serie.channel = channel
serie.url = url
p_dialog.update(int(math.ceil((i + 1) * t)), heading, "%s: %s" % (serie.contentSerieName,
serie.channel.capitalize()))
try:
pathchannels = filetools.join(config.get_runtime_path(), "channels", serie.channel + '.py')
logger.info("pelisalacarta.library_service Cargando canal: " + pathchannels + " " +
serie.channel)
if serie.library_filter_show:
serie.show = serie.library_filter_show.get(channel, serie.contentSerieName)
obj = imp.load_source(serie.channel, pathchannels)
itemlist = obj.episodios(serie)
try:
library.save_library_episodes(path, itemlist, serie, silent=True, overwrite=overwrite)
except Exception as ex:
logger.info("pelisalacarta.library_service Error al guardar los capitulos de la serie")
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
except Exception as ex:
logger.error("Error al obtener los episodios de: {0}".
format(serie.show))
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
p_dialog.close()
else:
logger.info("No actualiza la biblioteca, está desactivado en la configuración de pelisalacarta")
except Exception as ex:
logger.info("pelisalacarta.library_service Se ha producido un error al actualizar las series")
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
if p_dialog:
p_dialog.close()
def check_for_update(overwrite=True):
logger.info("Actualizando series...")
p_dialog = None
serie_actualizada = False
update_when_finished = False
hoy = datetime.date.today()
estado_verify_playcount_series = False
try:
if config.get_setting("update", "videolibrary") != 0 or overwrite:
config.set_setting("updatelibrary_last_check",
hoy.strftime('%Y-%m-%d'), "videolibrary")
heading = config.get_localized_string(60389)
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(20000), heading)
p_dialog.update(0, '')
show_list = []
for path, folders, files in filetools.walk(
videolibrarytools.TVSHOWS_PATH):
show_list.extend([
filetools.join(path, f) for f in files if f == "tvshow.nfo"
])
if show_list:
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
head_nfo, serie = videolibrarytools.read_nfo(tvshow_file)
path = filetools.dirname(tvshow_file)
logger.info("serie=" + serie.contentSerieName)
p_dialog.update(int(math.ceil((i + 1) * t)), heading,
serie.contentSerieName)
#Verificamos el estado del serie.library_playcounts de la Serie por si está incompleto
try:
estado = False
#Si no hemos hecho la verificación o no tiene playcount, entramos
estado = config.get_setting("verify_playcount",
"videolibrary")
if not estado or estado == False or not serie.library_playcounts: #Si no se ha pasado antes, lo hacemos ahora
serie, estado = videolibrary.verify_playcount_series(
serie, path
) #También se pasa si falta un PlayCount por completo
except:
logger.error(traceback.format_exc())
else:
if estado: #Si ha tenido éxito la actualización...
estado_verify_playcount_series = True #... se marca para cambiar la opción de la Videoteca
interval = int(serie.active) # Podria ser del tipo bool
if not serie.active:
# si la serie no esta activa descartar
if not overwrite:
#Sincronizamos los episodios vistos desde la videoteca de Kodi con la de Alfa, aunque la serie esté desactivada
try:
if config.is_xbmc(): #Si es Kodi, lo hacemos
from platformcode import xbmc_videolibrary
xbmc_videolibrary.mark_content_as_watched_on_alfa(
path + '/tvshow.nfo')
except:
logger.error(traceback.format_exc())
continue
# obtenemos las fecha de actualizacion y de la proxima programada para esta serie
update_next = serie.update_next
if update_next:
y, m, d = update_next.split('-')
update_next = datetime.date(int(y), int(m), int(d))
else:
update_next = hoy
update_last = serie.update_last
if update_last:
y, m, d = update_last.split('-')
update_last = datetime.date(int(y), int(m), int(d))
else:
update_last = hoy
# si la serie esta activa ...
if overwrite or config.get_setting("updatetvshows_interval",
"videolibrary") == 0:
# ... forzar actualizacion independientemente del intervalo
serie_actualizada = update(path, p_dialog, i, t, serie,
overwrite)
if not serie_actualizada:
update_next = hoy + datetime.timedelta(days=interval)
elif interval == 1 and update_next <= hoy:
# ...actualizacion diaria
serie_actualizada = update(path, p_dialog, i, t, serie,
overwrite)
if not serie_actualizada and update_last <= hoy - datetime.timedelta(
days=7):
# si hace una semana q no se actualiza, pasar el intervalo a semanal
interval = 7
update_next = hoy + datetime.timedelta(days=interval)
elif interval == 7 and update_next <= hoy:
# ...actualizacion semanal
serie_actualizada = update(path, p_dialog, i, t, serie,
overwrite)
if not serie_actualizada:
if update_last <= hoy - datetime.timedelta(days=14):
# si hace 2 semanas q no se actualiza, pasar el intervalo a mensual
interval = 30
update_next += datetime.timedelta(days=interval)
elif interval == 30 and update_next <= hoy:
# ...actualizacion mensual
serie_actualizada = update(path, p_dialog, i, t, serie,
overwrite)
if not serie_actualizada:
update_next += datetime.timedelta(days=interval)
if serie_actualizada:
update_last = hoy
update_next = hoy + datetime.timedelta(days=interval)
head_nfo, serie = videolibrarytools.read_nfo(
tvshow_file) #Vuelve a leer el.nfo, que ha sido modificado
if interval != int(serie.active) or update_next.strftime(
'%Y-%m-%d'
) != serie.update_next or update_last.strftime(
'%Y-%m-%d') != serie.update_last:
serie.update_last = update_last.strftime('%Y-%m-%d')
if update_next > hoy:
serie.update_next = update_next.strftime('%Y-%m-%d')
serie.active = interval
serie.channel = "videolibrary"
serie.action = "get_seasons"
filetools.write(tvshow_file, head_nfo + serie.tojson())
if serie_actualizada:
if config.get_setting("search_new_content",
"videolibrary") == 0:
# Actualizamos la videoteca de Kodi: Buscar contenido en la carpeta de la serie
if config.is_xbmc():
from platformcode import xbmc_videolibrary
xbmc_videolibrary.update(
folder=filetools.basename(path))
else:
update_when_finished = True
if estado_verify_playcount_series: #Si se ha cambiado algún playcount, ...
estado = config.set_setting(
"verify_playcount", True, "videolibrary"
) #... actualizamos la opción de Videolibrary
if config.get_setting(
"search_new_content",
"videolibrary") == 1 and update_when_finished:
# Actualizamos la videoteca de Kodi: Buscar contenido en todas las series
if config.is_xbmc():
from platformcode import xbmc_videolibrary
xbmc_videolibrary.update()
p_dialog.close()
else:
logger.info(
"No actualiza la videoteca, está desactivado en la configuración de alfa"
)
except Exception, ex:
logger.error("Se ha producido un error al actualizar las series")
template = "An exception of type %s occured. Arguments:\n%r"
message = template % (type(ex).__name__, ex.args)
logger.error(message)
if p_dialog:
p_dialog.close()
def play_from_library(item):
"""
Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener
más items, como mucho se puede colocar un dialogo de seleccion.
Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante
"Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas
las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para
la biblioteca.
@type item: item
@param item: elemento con información
"""
logger.info()
# logger.debug("item: \n" + item.tostring('\n'))
import xbmcgui
import xbmcplugin
import xbmc
# Intentamos reproducir una imagen (esto no hace nada y ademas no da error)
xbmcplugin.setResolvedUrl(int(sys.argv[1]), True,
xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png")))
# Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion
xbmc.Player().stop()
# modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes
item.action = "findvideos"
window_type = config.get_setting("window_type", "biblioteca")
# y volvemos a lanzar kodi
if xbmc.getCondVisibility('Window.IsMedia') and not window_type == 1:
# Ventana convencional
xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")")
else:
# Ventana emergente
from channels import biblioteca
p_dialog = platformtools.dialog_progress_bg('streamondemand', 'Caricamento in corso...')
p_dialog.update(0, '')
itemlist = biblioteca.findvideos(item)
p_dialog.update(50, '')
# Se filtran los enlaces segun la lista blanca y negra
if config.get_setting('filter_servers') == 'true':
itemlist = filtered_servers(itemlist)
# Se limita la cantidad de enlaces a mostrar
if config.get_setting("max_links", "biblioteca") != 0:
itemlist = limit_itemlist(itemlist)
# Se "limpia" ligeramente la lista de enlaces
if config.get_setting("replace_VD", "biblioteca") == 1:
itemlist = reorder_itemlist(itemlist)
p_dialog.update(100, '')
xbmc.sleep(500)
p_dialog.close()
if len(itemlist) > 0:
# El usuario elige el mirror
opciones = []
for item in itemlist:
opciones.append(item.title)
# Se abre la ventana de seleccion
if (item.contentSerieName != "" and
item.contentSeason != "" and
item.contentEpisodeNumber != ""):
cabecera = ("%s - %sx%s -- %s" %
(item.contentSerieName,
item.contentSeason,
item.contentEpisodeNumber,
config.get_localized_string(30163)))
else:
cabecera = config.get_localized_string(30163)
seleccion = platformtools.dialog_select(cabecera, opciones)
if seleccion == -1:
return
else:
item = biblioteca.play(itemlist[seleccion])[0]
platformtools.play_video(item)
def overwrite_tools(item):
import videolibrary_service
from core import videolibrarytools
seleccion = platformtools.dialog_yesno(config.get_localized_string(60581),
config.get_localized_string(60582),
config.get_localized_string(60583))
if seleccion == 1:
# tvshows
heading = config.get_localized_string(60584)
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(60585), heading)
p_dialog.update(0, '')
show_list = []
for path, folders, files in filetools.walk(
videolibrarytools.TVSHOWS_PATH):
show_list.extend(
[filetools.join(path, f) for f in files if f == "tvshow.nfo"])
if show_list:
t = float(100) / len(show_list)
for i, tvshow_file in enumerate(show_list):
head_nfo, serie = videolibrarytools.read_nfo(tvshow_file)
path = filetools.dirname(tvshow_file)
if not serie.active:
# si la serie no esta activa descartar
continue
# Eliminamos la carpeta con la serie ...
filetools.rmdirtree(path)
# ... y la volvemos a añadir
videolibrary_service.update(path, p_dialog, i, t, serie, 3)
p_dialog.close()
# movies
heading = config.get_localized_string(60586)
p_dialog2 = platformtools.dialog_progress_bg(
config.get_localized_string(60585), heading)
p_dialog2.update(0, '')
movies_list = []
for path, folders, files in filetools.walk(
videolibrarytools.MOVIES_PATH):
movies_list.extend([
filetools.join(path, f) for f in files if f.endswith(".json")
])
logger.debug("movies_list %s" % movies_list)
if movies_list:
t = float(100) / len(movies_list)
for i, movie_json in enumerate(movies_list):
try:
from core import jsontools
path = filetools.dirname(movie_json)
movie = Item().fromjson(filetools.read(movie_json))
# Eliminamos la carpeta con la pelicula ...
filetools.rmdirtree(path)
import math
heading = config.get_localized_string(60587)
p_dialog2.update(
int(math.ceil((i + 1) * t)), heading, "%s: %s" %
(movie.contentTitle, movie.channel.capitalize()))
# ... y la volvemos a añadir
videolibrarytools.save_movie(movie)
except Exception, ex:
logger.error("Error al crear de nuevo la película")
template = "An exception of type %s occured. Arguments:\n%r"
message = template % (type(ex).__name__, ex.args)
logger.error(message)
p_dialog2.close()
def find_and_set_infoLabels(item):
logger.info()
# logger.info("item es %s" % item)
p_dialog = None
if not item.contentSeason:
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(60296),
config.get_localized_string(60293))
global otvdb_global
tvdb_result = None
title = item.contentSerieName
# Si el titulo incluye el (año) se lo quitamos
year = scrapertools.find_single_match(title, "^.+?\s*(\(\d{4}\))$")
if year:
title = title.replace(year, "").strip()
item.infoLabels['year'] = year[1:-1]
if not item.infoLabels.get("tvdb_id"):
if not item.infoLabels.get("imdb_id"):
otvdb_global = Tvdb(search=title, year=item.infoLabels['year'])
else:
otvdb_global = Tvdb(imdb_id=item.infoLabels.get("imdb_id"))
elif not otvdb_global or otvdb_global.get_id(
) != item.infoLabels['tvdb_id']:
otvdb_global = Tvdb(tvdb_id=item.infoLabels['tvdb_id'])
if not item.contentSeason:
p_dialog.update(50, config.get_localized_string(60296),
config.get_localized_string(60295))
results, info_load = otvdb_global.get_list_results()
logger.debug("results es %s" % results)
if not item.contentSeason:
p_dialog.update(100, config.get_localized_string(60296),
config.get_localized_string(60297) % len(results))
p_dialog.close()
if len(results) > 1:
tvdb_result = platformtools.show_video_info(
results,
item=item,
scraper=Tvdb,
caption=config.get_localized_string(60298) % title)
elif len(results) > 0:
tvdb_result = results[0]
# todo revisar
if isinstance(item.infoLabels, InfoLabels):
logger.debug("es instancia de infoLabels")
infoLabels = item.infoLabels
else:
logger.debug("NO ES instancia de infoLabels")
infoLabels = InfoLabels()
if tvdb_result:
infoLabels['tvdb_id'] = tvdb_result['id']
infoLabels['url_scraper'] = [
"http://thetvdb.com/index.php?tab=series&id=%s" %
infoLabels['tvdb_id']
]
if not info_load:
if otvdb_global.get_id() != infoLabels['tvdb_id']:
otvdb_global = Tvdb(tvdb_id=infoLabels['tvdb_id'])
otvdb_global.get_images(infoLabels['tvdb_id'], image="poster")
otvdb_global.get_images(infoLabels['tvdb_id'], image="fanart")
otvdb_global.get_tvshow_cast(infoLabels['tvdb_id'])
item.infoLabels = infoLabels
set_infoLabels_item(item)
return True
else:
item.infoLabels = infoLabels
return False
def find_and_set_infoLabels(item):
logger.info()
# logger.info("item es %s" % item)
p_dialog = None
if not item.contentSeason:
p_dialog = platformtools.dialog_progress_bg("Buscando información de la serie", "Espere por favor...")
global otvdb_global
tvdb_result = None
title = item.contentSerieName
# Si el titulo incluye el (año) se lo quitamos
year = scrapertools.find_single_match(title, "^.+?\s*(\(\d{4}\))$")
if year:
title = title.replace(year, "").strip()
item.infoLabels['year'] = year[1:-1]
if not item.infoLabels.get("tvdb_id"):
if not item.infoLabels.get("imdb_id"):
otvdb_global = Tvdb(search=title, year=item.infoLabels['year'])
else:
otvdb_global = Tvdb(imdb_id=item.infoLabels.get("imdb_id"))
elif not otvdb_global or otvdb_global.get_id() != item.infoLabels['tvdb_id']:
otvdb_global = Tvdb(tvdb_id=item.infoLabels['tvdb_id']) # , tipo=tipo_busqueda, idioma_busqueda="es")
if not item.contentSeason:
p_dialog.update(50, "Buscando información de la serie", "Obteniendo resultados...")
results, info_load = otvdb_global.get_list_results()
logger.debug("results es %s" % results)
if not item.contentSeason:
p_dialog.update(100, "Buscando información de la serie", "Encontrados %s posibles coincidencias" % len(results))
p_dialog.close()
if len(results) > 1:
tvdb_result = platformtools.show_video_info(results, item=item, scraper=Tvdb,
caption="[%s]: Selecciona la serie correcta" % title)
elif len(results) > 0:
tvdb_result = results[0]
# todo revisar
if isinstance(item.infoLabels, InfoLabels):
logger.debug("es instancia de infoLabels")
infoLabels = item.infoLabels
else:
logger.debug("NO ES instancia de infoLabels")
infoLabels = InfoLabels()
if tvdb_result:
infoLabels['tvdb_id'] = tvdb_result['id']
infoLabels['url_scraper'] = ["http://thetvdb.com/index.php?tab=series&id=%s" % infoLabels['tvdb_id']]
if not info_load:
if otvdb_global.get_id() != infoLabels['tvdb_id']:
otvdb_global = Tvdb(tvdb_id=infoLabels['tvdb_id'])
otvdb_global.get_images(infoLabels['tvdb_id'], image="poster")
otvdb_global.get_images(infoLabels['tvdb_id'], image="fanart")
otvdb_global.get_tvshow_cast(infoLabels['tvdb_id'])
item.infoLabels = infoLabels
set_infoLabels_item(item)
return True
else:
item.infoLabels = infoLabels
return False
def play_from_library(item):
"""
The .strm files when played from kodi, this expects it to be a "playable" file so it cannot contain
more items, at most a selection dialog can be placed.
We solve this by "cheating kodi" and making him believe that something has been reproduced, so later by
"Container.Update ()" we load the strm as if an item from inside the addon were treated, removing all
the limitations and allowing to reproduce through the general function without having to create new methods to
the video library.
@type item: item
@param item: item with information
"""
def get_played_time(item):
if item.contentType == 'movie': nfo_path = item.nfo
else: nfo_path = item.strm_path.replace('strm', 'nfo')
if nfo_path and filetools.isfile(nfo_path):
from core import videolibrarytools
head_nfo, item_nfo = videolibrarytools.read_nfo(nfo_path)
sleep(1)
played_time = platformtools.get_played_time(item_nfo)
else:
played_time = 0
return played_time
import xbmcgui, xbmcplugin, xbmc
from time import sleep
# logger.debug("item: \n" + item.tostring('\n'))
platformtools.prevent_busy(item)
itemlist = []
item.fromLibrary = True
item.window = True
logger.debug()
# Modify the action (currently the video library needs "findvideos" since this is where the sources are searched
item.action = "findvideos"
window_type = config.get_setting("window_type", "videolibrary")
# and launch kodi again
if xbmc.getCondVisibility('Window.IsMedia') and not window_type == 1:
xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" +
item.tourl() + ")")
else:
# Pop-up window
from specials import videolibrary
p_dialog = platformtools.dialog_progress_bg(
config.get_localized_string(20000),
config.get_localized_string(60683))
p_dialog.update(0, '')
item.play_from = 'window'
itemlist = videolibrary.findvideos(item)
p_dialog.update(100, '')
sleep(0.5)
p_dialog.close()
played = False
# The number of links to show is limited
if config.get_setting("max_links", "videolibrary") != 0:
itemlist = limit_itemlist(itemlist)
# The list of links is slightly "cleaned"
if config.get_setting("replace_VD", "videolibrary") == 1:
itemlist = reorder_itemlist(itemlist)
# from core.support import dbg;dbg()
if len(itemlist) > 0:
reopen = False
while not xbmc.Monitor().abortRequested():
played = True
# The user chooses the mirror
if not platformtools.is_playing():
# from core.support import dbg;dbg()
if config.get_setting('autoplay') or reopen:
played_time = get_played_time(item)
if not played_time and played:
return
options = []
selection_implementation = 0
for item in itemlist:
item.thumbnail = config.get_online_server_thumb(
item.server)
quality = '[B][' + item.quality + '][/B]' if item.quality else ''
if item.server:
path = filetools.join(
config.get_runtime_path(), 'servers',
item.server.lower() + '.json')
name = jsontools.load(open(path,
"r").read())['name']
if name.startswith('@'):
name = config.get_localized_string(
int(name.replace('@', '')))
it = xbmcgui.ListItem(
'\n[B]%s[/B] %s - %s' %
(name, quality, item.contentTitle))
it.setArt({'thumb': item.thumbnail})
options.append(it)
else:
selection_implementation += 1
# The selection window opens
if (item.contentSerieName and item.contentSeason
and item.contentEpisodeNumber):
head = ("%s - %sx%s | %s" %
(item.contentSerieName, item.contentSeason,
item.contentEpisodeNumber,
config.get_localized_string(30163)))
else:
head = config.get_localized_string(30163)
selection = platformtools.dialog_select(head,
options,
preselect=-1,
useDetails=True)
if selection == -1:
return
else:
item = videolibrary.play(
itemlist[selection + selection_implementation])[0]
platformtools.play_video(item)
reopen = True
def main():
logger.info("pelisalacarta.library_service Actualizando series...")
directorio = library.join_path(config.get_library_path(), "SERIES")
logger.info("directorio="+directorio)
if not library.path_exists(directorio):
library.make_dir(directorio)
library.check_tvshow_xml()
try:
if config.get_setting("updatelibrary") == "true":
data, dict_data = lib_data()
heading = 'Actualizando biblioteca....'
p_dialog = platformtools.dialog_progress_bg('pelisalacarta', heading)
p_dialog.update(0, '')
i = 0
# fix float porque la division se hace mal en python 2.x
t = float(100) / len(dict_data.keys())
for tvshow_id in dict_data.keys():
logger.info("pelisalacarta.library_service serie="+dict_data[tvshow_id]["name"])
for channel in dict_data[tvshow_id]["channels"].keys():
carpeta = "{0} [{1}]".format(library.title_to_filename(
dict_data[tvshow_id]["channels"][channel]["tvshow"].lower()), channel)
# carpeta = dict_serie[tvshow_id]["channels"][channel]["path"]
ruta = library.join_path(config.get_library_path(), "SERIES", carpeta)
logger.info("pelisalacarta.library_service ruta =#"+ruta+"#")
i += 1
if library.path_exists(ruta):
logger.info("pelisalacarta.library_service Actualizando "+carpeta)
logger.info("pelisalacarta.library_service url " +
dict_data[tvshow_id]["channels"][channel]["url"])
p_dialog.update(int(math.ceil(i * t)), heading, dict_data[tvshow_id]["name"])
item = Item(url=dict_data[tvshow_id]["channels"][channel]["url"],
show=dict_data[tvshow_id]["channels"][channel]["tvshow"], channel=channel)
try:
pathchannels = library.join_path(config.get_runtime_path(), 'channels', channel + '.py')
logger.info("pelisalacarta.library_service Cargando canal " + pathchannels + " " + channel)
obj = imp.load_source(channel, pathchannels)
itemlist = obj.episodios(item)
try:
library.save_library_tvshow(item, itemlist)
except Exception as ex:
logger.info("pelisalacarta.library_service Error al guardar los capitulos de la serie")
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
except Exception as ex:
logger.error("Error al obtener los episodios de: {0}".
format(dict_data[tvshow_id]["channels"][channel]["tvshow"]))
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.info(message)
else:
logger.info("pelisalacarta.library_service No actualiza {0} (no existe el directorio)".
format(dict_data[tvshow_id]["name"]))
p_dialog.update(int(math.ceil(i * t)), 'Error al obtener ruta...', dict_data[tvshow_id]["name"])
p_dialog.close()
library.update()
else:
logger.info("No actualiza la biblioteca, está desactivado en la configuración de pelisalacarta")
except Exception as ex:
import traceback
logger.info(traceback.format_exc())
if p_dialog:
p_dialog.close()
