def get_list_canales():
logger.info("streamondemand.channels.novedades get_list_canales")
list_canales = {'peliculas': [], 'infantiles': [], 'series': [], 'anime': [], 'documentales': []}
# Rellenar listas de canales disponibles
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
for infile in sorted(glob.glob(channels_path)):
list_result_canal = []
channel_id = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_id)
# No incluir si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No incluir 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 incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# Incluir en cada categoria, si en su configuracion el canal esta activado para mostrar novedades
for categoria in list_canales:
include_in_newest = config.get_setting("include_in_newest_" + categoria, channel_id)
if include_in_newest:
channels_ID_name[channel_id] = channel_parameters["title"]
list_canales[categoria].append((channel_id,channel_parameters["title"]))
return list_canales
def channel_status(item, dict_values):
try:
for v in dict_values:
if v == "all_channels":
import channelselector
from core import channeltools
logger.info("Todos los canales | Estado seleccionado: %s" %
str(dict_values[v]).lower())
if str(dict_values[v]) != "0":
channel_list = channelselector.filterchannels("allchannelstatus")
excluded_channels = ['tengourl', 'buscador',
'libreria', 'configuracion',
'novedades', 'personal',
'ayuda', 'descargas']
for channel in channel_list:
if channel.channel not in excluded_channels:
channel_parameters = channeltools.get_channel_parameters(channel.channel)
new_status_all_default = None
new_status_all = None
new_status_all_default = channel_parameters["active"]
# Opcion Activar todos
if str(dict_values[v]) == "1":
new_status_all = "true"
# Opcion Desactivar todos
if str(dict_values[v]) == "2":
new_status_all = "false"
# Opcion Recuperar estado por defecto
if str(dict_values[v]) == "3":
# Si tiene "enabled" en el json es porque el estado no es el del xml
if config.get_setting("enabled", channel.channel):
new_status_all = new_status_all_default
# Si el canal no tiene "enabled" en el json no se guarda, se pasa al siguiente
else:
continue
# Se guarda el estado del canal
if new_status_all is not None:
config.set_setting("enabled", new_status_all, channel.channel)
break
else:
continue
else:
logger.info("Canal: %s | Estado: %s" %
(v, str(dict_values[v]).lower()))
config.set_setting("enabled", str(dict_values[v]).lower(), v)
platformtools.itemlist_update(Item(channel=CHANNELNAME, action="mainlist"))
except:
import traceback
logger.info("Detalle del error: %s" % traceback.format_exc())
platformtools.dialog_notification("Error",
"Se ha producido un error al guardar")
def filterchannels(category,preferred_thumb=""):
logger.info("channelselector.filterchannels")
try:
idioma = config.get_setting("languagefilter")
logger.info("channelselector.filterchannels idioma=%s" % idioma)
langlistv = ["","ES","EN","IT","PT"]
idiomav = langlistv[int(idioma)]
logger.info("channelselector.filterchannels idiomav=%s" % idiomav)
except:
idiomav=""
activechannels = []
channelslist =[]
category=category.replace("L","latino").replace("M","music").replace("X","adult").replace("T","torrent").replace("VOS","vos").replace("F","movie").replace("S","serie").replace("D","documentary").replace("A","anime").replace("*","all")
channel_path = os.path.join(config.get_runtime_path(),"channels")
logger.info("channelselector.filterchannels channel_path="+channel_path)
for channel in os.listdir(channel_path):
logger.info("channelselector.filterchannels channel="+channel)
if channel.endswith(".xml"):
try:
ChannelData = channeltools.get_channel_parameters(channel[:-4])
if not ChannelData["thumbnail"]:
ChannelData["thumbnail"] = get_thumbnail_path(preferred_thumb)+ChannelData["channel"]+".png"
else:
# Si prefiere el bannermenu y el canal lo tiene, cambia ahora de idea
if preferred_thumb=="bannermenu" and "bannermenu" in ChannelData:
ChannelData["thumbnail"]=ChannelData["bannermenu"]
if not ChannelData["active"] == "true": continue #Si no esta activo lo saltamos
if ChannelData["adult"] == "true" and not config.get_setting("adult_mode") == "true": continue # Si es adulto y no estan activados lo saltamos
if not category=="all" and not category in ChannelData["category"] and not "all" in ChannelData["category"]: continue #Si no corresponde la categoria lo saltamos
if not ChannelData["language"]=="" and not idiomav=="" and not idiomav.lower() in ChannelData["language"]: continue #Si no corresponde el idioma lo saltamos
if ChannelData["channel"]=="tengourl":
channelslist.append(Item(title=ChannelData["title"], channel=ChannelData["channel"], action="mainlist", thumbnail=ChannelData["thumbnail"] , fanart=ChannelData["fanart"], category=", ".join(ChannelData["category"])[:-2], language=ChannelData["language"], type=ChannelData["type"] ))
else:
activechannels.append(Item(title=ChannelData["title"], channel=ChannelData["channel"], action="mainlist", thumbnail=ChannelData["thumbnail"] , fanart=ChannelData["fanart"] , category=", ".join(ChannelData["category"])[:-2], language=ChannelData["language"], type=ChannelData["type"] ))
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel)
import traceback
logger.info(traceback.format_exc())
if config.get_setting("personalchannel")=="true":
channelslist.append( Item( title=config.get_setting("personalchannelname") ,action="mainlist", channel="personal" ,thumbnail=config.get_setting("personalchannellogo"), language="" , category="F,S,D,A" , type="generic" ))
if config.get_setting("personalchannel2")=="true":
channelslist.append( Item( title=config.get_setting("personalchannelname2") ,action="mainlist", channel="personal2" ,thumbnail=config.get_setting("personalchannellogo2"), language="" , category="F,S,D,A" , type="generic" ))
if config.get_setting("personalchannel3")=="true":
channelslist.append( Item( title=config.get_setting("personalchannelname3") ,action="mainlist", channel="personal3" ,thumbnail=config.get_setting("personalchannellogo3"), language="" , category="F,S,D,A" , type="generic" ))
if config.get_setting("personalchannel4")=="true":
channelslist.append( Item( title=config.get_setting("personalchannelname4") ,action="mainlist", channel="personal4" ,thumbnail=config.get_setting("personalchannellogo4"), language="" , category="F,S,D,A" , type="generic" ))
if config.get_setting("personalchannel5")=="true":
channelslist.append( Item( title=config.get_setting("personalchannelname5") ,action="mainlist", channel="personal5" ,thumbnail=config.get_setting("personalchannellogo5"), language="" , category="F,S,D,A" , type="generic" ))
activechannels.sort(key=lambda item: item.title.lower().strip())
channelslist.extend(activechannels)
return channelslist
def getchanneltypes(preferred_thumb=""):
logger.info("channelselector getchanneltypes")
# Lista de categorias
valid_types = [ "movie","serie","anime","documentary","vos","torrent","latino","adult"]
# Lee la lista de canales
channel_path = os.path.join( config.get_runtime_path() , "channels" , '*.xml' )
logger.info("channelselector.getchanneltypes channel_path="+channel_path)
channel_files = glob.glob(channel_path)
channel_language = config.get_setting("channel_language")
logger.info("channelselector.getchanneltypes channel_language="+channel_language)
# Construye la lista de tipos
channel_types = []
for index, channel in enumerate(channel_files):
logger.info("channelselector.getchanneltypes channel="+channel)
if channel.endswith(".xml"):
try:
channel_parameters = channeltools.get_channel_parameters(channel[:-4])
logger.info("channelselector.filterchannels channel_parameters="+repr(channel_parameters))
# Si es un canal para adultos y el modo adulto está desactivado, se lo salta
if channel_parameters["adult"]=="true" and config.get_setting("adult_mode")=="false":
continue
# Si el canal está en un idioma filtrado
if channel_language!="all" and channel_parameters["language"]!=channel_language:
continue
categories = channel_parameters["categories"]
for category in categories:
logger.info("channelselector.filterchannels category="+category)
if category not in channel_types and category in valid_types:
channel_types.append(category)
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel + traceback.format_exc())
logger.info("channelselector.getchanneltypes Encontrados:")
for channel_type in channel_types:
logger.info("channelselector.getchanneltypes channel_type="+channel_type)
# Ahora construye el itemlist ordenadamente
itemlist = []
itemlist.append( Item( title=config.get_localized_string(30121) , channel="channelselector" , action="listchannels" , category="all" , thumbnail=urlparse.urljoin(get_thumbnail_path(preferred_thumb),"thumb_canales_todos.png")))
logger.info("channelselector.getchanneltypes Ordenados:")
for channel_type in valid_types:
logger.info("channelselector.getchanneltypes channel_type="+channel_type)
if channel_type in channel_types:
itemlist.append( Item( title=channel_type , channel="channelselector" , action="listchannels" , category=channel_type , thumbnail=urlparse.urljoin(get_thumbnail_path(preferred_thumb),"thumb_canales_"+channel_type+".png")))
return itemlist
def settingCanal(item):
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
list_controls = []
for infile in sorted(glob.glob(channels_path)):
channel_name = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_name)
# No incluir si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No incluir si es un canal para adultos, y el modo adulto está desactivado
if channel_parameters["adult"] == "true" and config.get_setting("adult_mode") == "0":
continue
# No incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# No incluir si en la configuracion del canal no existe "include_in_global_search"
include = channel_parameters["include_in_global_search"]
if include not in ["", "true"]:
continue
else:
# Se busca en la configuración del canal el valor guardado
include_in_global_search = config.get_setting("include_in_global_search", channel_name)
# Si no hay valor en la configuración del canal se coloca como True ya que así estaba por defecto
if include_in_global_search == "":
include_in_global_search = True
control = {'id': channel_name,
'type': "bool",
'label': channel_parameters["title"],
'default': include_in_global_search,
'enabled': True,
'visible': True}
list_controls.append(control)
return platformtools.show_channel_settings(list_controls=list_controls,
caption="Canales incluidos en la búsqueda global",
callback="save_settings", item=item, custom_button={'visible': False})
def get_list_canales():
logger.info()
list_canales = {
'peliculas': [],
'infantiles': [],
'series': [],
'anime': [],
'documentales': []
}
# Rellenar listas de canales disponibles
channels_path = os.path.join(config.get_runtime_path(), "channels",
'*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
for infile in sorted(glob.glob(channels_path)):
list_result_canal = []
channel_id = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_id)
# No incluir si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No incluir 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 incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters[
"language"] != channel_language:
continue
# Incluir en cada categoria, si en su configuracion el canal esta activado para mostrar novedades
for categoria in list_canales:
include_in_newest = config.get_setting(
"include_in_newest_" + categoria, channel_id)
if include_in_newest:
channels_ID_name[channel_id] = channel_parameters["title"]
list_canales[categoria].append(
(channel_id, channel_parameters["title"]))
return list_canales
def makeItem(self, item):
logger.debug()
thumb = item.thumbnail if item.thumbnail else 'Infoplus/' + item.contentType.replace('show','') + 'png'
logger.info('THUMB', thumb)
it = xbmcgui.ListItem(item.title)
it.setProperty('thumb', thumb)
it.setProperty('fanart', item.fanart)
it.setProperty('plot', item.plot)
it.setProperty('verified', item.verified)
if item.server:
color = scrapertools.find_single_match(item.alive, r'(FF[^\]]+)')
it.setProperty('channel', channeltools.get_channel_parameters(item.channel).get('title',''))
it.setProperty('thumb', "https://raw.githubusercontent.com/kodiondemand/media/master/resources/servers/%s.png" % item.server.lower())
it.setProperty('servername', servertools.get_server_parameters(item.server.lower()).get('name',item.server))
it.setProperty('color', color if color else 'FF0082C2')
return it
def get_channels_list():
logger.info()
list_canales = {
'peliculas': [],
'terror': [],
'infantiles': [],
'series': [],
'anime': [],
'documentales': []
}
any_active = False
# Rellenar listas de canales disponibles
channels_path = os.path.join(config.get_runtime_path(), "channels",
'*.json')
channel_language = config.get_setting("channel_language", default="all")
for infile in sorted(glob.glob(channels_path)):
channel_id = os.path.basename(infile)[:-5]
channel_parameters = channeltools.get_channel_parameters(channel_id)
# No incluir si es un canal inactivo
if not channel_parameters["active"]:
continue
# No incluir si es un canal para adultos, y el modo adulto está desactivado
if channel_parameters["adult"] and config.get_setting(
"adult_mode") == 0:
continue
# No incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_language not in channel_parameters["language"] \
and "*" not in channel_parameters["language"]:
continue
# Incluir en cada categoria, si en su configuracion el canal esta activado para mostrar novedades
for categoria in list_canales:
include_in_newest = config.get_setting(
"include_in_newest_" + categoria, channel_id)
if include_in_newest:
channels_id_name[channel_id] = channel_parameters["title"]
list_canales[categoria].append(
(channel_id, channel_parameters["title"]))
any_active = True
return list_canales, any_active
def settingCanal(item):
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
list_controls = []
for infile in sorted(glob.glob(channels_path)):
channel_name = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_name)
# No incluir si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No incluir 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 incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# No incluir si en la configuracion del canal no existe "include_in_global_search"
include = channel_parameters["include_in_global_search"]
if include not in ["", "true"]:
continue
else:
# Se busca en la configuración del canal el valor guardado
include_in_global_search = config.get_setting("include_in_global_search",channel_name)
# Si no hay valor en la configuración del canal se coloca como True ya que así estaba por defecto
if include_in_global_search == "":
include_in_global_search = True
control = {'id': channel_name,
'type': "bool",
'label': channel_parameters["title"],
'default': include_in_global_search,
'enabled': True,
'visible': True}
list_controls.append(control)
return platformtools.show_channel_settings(list_controls=list_controls, caption= "Canales incluidos en la búsqueda global", callback="save_settings", item=item)
def alpha_list(item):
logger.info()
itemlist = []
soup = create_soup(item.url)
matches = soup.find("tbody")
if not matches:
return itemlist
for elem in matches.find_all("tr"):
info = elem.find("td", class_="MvTbTtl")
thumb = elem.img["data-src"]
# thumb = elem.img["src"]
url = info.a["href"]
title = info.a.text.strip()
year = elem.find_all('td')[4].text
itemlist.append(
item.clone(action="findvideos",
url=url,
title=title,
contentTitle=title,
thumbnail=thumb,
infoLabels={"year": year}))
tmdb.set_infoLabels_itemlist(itemlist, True)
if not config.get_setting(
'unify') and not channeltools.get_channel_parameters(
__channel__)['force_unify']:
a = len(itemlist) - 1
for i in itemlist:
if a >= 0:
title = itemlist[a].contentTitle
titulo = itemlist[a].title
titulo = scrapertools.find_single_match(
titulo, '(\\[COLOR[^"]+)')
title = "%s %s" % (title, titulo)
itemlist[a].title = title
a -= 1
next_page = soup.find('a', class_='current')
if next_page and next_page.find_next_sibling("a"):
next_page = next_page.find_next_sibling("a")['href']
next_page = urlparse.urljoin(item.url, next_page)
itemlist.append(
item.clone(action="alpha_list",
title="[COLOR blue]Página Siguiente >>[/COLOR]",
url=next_page))
return itemlist
def findvideos(item):
logger.info()
db = trackingtools.TrackingData()
opciones = []; opciones_row = []
if item.contentType == 'movie':
rows = db.get_movie_channels(item.infoLabels['tmdb_id'])
infolabels = db.get_movie(item.infoLabels['tmdb_id'])
else:
rows = db.get_episode_channels(item.infoLabels['tmdb_id'], item.infoLabels['season'], item.infoLabels['episode'])
infolabels = db.get_episode(item.infoLabels['tmdb_id'], item.infoLabels['season'], item.infoLabels['episode'])
from core import channeltools
for channel, url in rows:
ch_parms = channeltools.get_channel_parameters(channel)
if ch_parms['active']: # no tener en cuenta canales que ya no existan o estén desactivados
opciones.append(platformtools.listitem_to_select(ch_parms['name'], '', ch_parms['thumbnail']))
opciones_row.append([channel, url])
db.close()
if len(opciones) == 0:
platformtools.dialog_ok(config.__addon_name, 'No tienes guardado ningún canal en activo con enlaces.')
return None
elif len(opciones) == 1: # Sólo hay un canal, ir a él directamente
ret = 0
else:
# TODO? canal preferente preseleccionado u ordenar por updated o último usado ?
ret = platformtools.dialog_select('¿ De qué canal quieres los enlaces ?', opciones, useDetails=True)
if ret == -1:
return None # pedido cancel
it_sel = Item().fromurl(opciones_row[ret][1])
it_sel.infoLabels = infolabels # Añadir infoLabels pq las urls se guardan sin ellos
logger.debug(it_sel)
canal = __import__('channels.' + opciones_row[ret][0], fromlist=[''])
if hasattr(canal, 'findvideos'):
itemlist = canal.findvideos(it_sel)
else:
itemlist = servertools.find_video_items(it_sel)
return itemlist
def get_channels_list():
logger.debug()
## import web_pdb; web_pdb.set_trace()
## list_canales = {'peliculas': [], '4k': [], 'terror': [], 'infantiles': [], 'series': [], 'anime': [],
## 'castellano': [], 'latino':[], 'italiano':[], 'torrent':[], 'documentales': []}
list_canales = {
'peliculas': [],
'series': [],
'anime': [],
'documentales': []
}
any_active = False
# Fill available channel lists
channels_path = os.path.join(config.get_runtime_path(), "channels",
'*.json')
channel_language = config.get_setting("channel_language", default="all")
if channel_language == "auto":
channel_language = auto_filter()
for infile in sorted(glob.glob(channels_path)):
channel_id = os.path.basename(infile)[:-5]
channel_parameters = channeltools.get_channel_parameters(channel_id)
# Do not include if it is an inactive channel
if not channel_parameters["active"]:
continue
# Do not include if the channel is in a filtered language
if channel_language != "all" and channel_language not in str(channel_parameters["language"]) \
and "*" not in channel_parameters["language"]:
continue
# Include in each category, if in your configuration the channel is activated to show news
for categoria in list_canales:
include_in_newest = config.get_setting(
"include_in_newest_" + categoria, channel_id)
if include_in_newest:
channels_id_name[channel_id] = channel_parameters["title"]
list_canales[categoria].append(
(channel_id, channel_parameters["title"]))
any_active = True
return list_canales, any_active
def get_channels(category, all=False):
logger.info()
valid_channels = list()
all_channels = channelselector.filterchannels('all')
for ch in all_channels:
channel = ch.channel
ch_param = channeltools.get_channel_parameters(channel)
if not ch_param.get("active", False):
continue
valid = config.get_setting("include_in_newest_" + category, channel)
if valid or (valid is not None and all):
valid_channels.append(channel)
return valid_channels
def search(item, texto):
logger.info("[searchchannel.py] search texto="+texto)
itemlist = []
directory = os.path.join(config.get_runtime_path(), "channels", '*.xml')
files = glob.glob(directory)
for file in files:
file = file.replace(".xml", "")
channel_parameters = channeltools.get_channel_parameters(file)
if channel_parameters['active'] == "true":
file = os.path.basename(file)
if DEBUG: logger.info("File .xml trovato: " + file)
texto = texto.lower().replace("+", "")
name = channel_parameters['title'].lower().replace(" ", "")
if texto in name:
itemlist.append(Item(title=channel_parameters['title'], action="mainlist", channel=file, thumbnail=channel_parameters["thumbnail"], type="generic", viewmode="movie"))
return itemlist
def search(item, texto):
logger.info("[searchchannel.py] search texto=" + texto)
itemlist = []
directory = os.path.join(config.get_runtime_path(), "channels", '*.xml')
files = glob.glob(directory)
for file in files:
file = file.replace(".xml", "")
channel_parameters = channeltools.get_channel_parameters(file)
if channel_parameters['active'] == True:
file = os.path.basename(file)
texto = texto.lower().replace("+", "")
name = channel_parameters['title'].lower().replace(" ", "")
if texto in name:
itemlist.append(Item(title=channel_parameters['title'], action="mainlist", channel=file,
thumbnail=channel_parameters["thumbnail"], type="generic", viewmode="movie"))
return itemlist
def findvideos(item):
video_urls = []
headers = {'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.8.1.14) Gecko/20080404 Firefox/2.0.0.14',
'content-type': 'application/json;charset=UTF-8',
'Referer': 'https://streamingcommunity.net'}
data = support.match(item, headers=headers).data.replace('"','"').replace('\\','')
url = support.match(data, patron=r'video_url"\s*:\s*"([^"]+)"').match
def videourls(res):
newurl = '{}/{}'.format(url, res)
if requests.head(newurl, headers=headers).status_code == 200:
video_urls.append(["m3u8 {} [StreamingCommunity]".format(res), newurl])
with futures.ThreadPoolExecutor() as executor:
for res in ['480p', '720p', '1080p']:
executor.submit(videourls, res)
if not video_urls: video_urls = [["m3u8 [StreamingCommunity]", url]]
else: video_urls.sort(key=lambda url: int(support.match(url[0], patron=r'(\d+)p').match))
itemlist = [item.clone(title = channeltools.get_channel_parameters(item.channel)['title'], server='directo', video_urls=video_urls, thumbnail=channeltools.get_channel_parameters(item.channel)["thumbnail"], forcethumb=True)]
return support.server(item, itemlist=itemlist)
def mainlist(item):
logger.info()
itemlist = list()
if alfa_assistant.is_alfa_installed():
autoplay.init(item.channel, list_servers, list_quality)
itemlist.append(Item(channel=item.channel, action="novedades_episodios", title="Últimos episodios",
url=HOST+'anime-online.html', thumbnail="https://i.imgur.com/w941jbR.png"))
itemlist.append(Item(channel=item.channel, action="novedades_anime", title="Últimos animes",
url=HOST+'anime-online.html', thumbnail="https://i.imgur.com/hMu5RR7.png"))
itemlist.append(Item(channel=item.channel, action="listado", title="Animes",
url=HOST + "animes/nombre/lista", thumbnail='https://i.imgur.com/50lMcjW.png'))
itemlist.append(Item(channel=item.channel, action="search_section",
title="Géneros", url=HOST + "animes",
extra="genre", thumbnail='https://i.imgur.com/Xj49Wa7.png'))
itemlist.append(Item(channel=item.channel, action="search", title="Buscar...",
thumbnail='https://i.imgur.com/4jH5gpT.png'))
itemlist = renumbertools.show_option(item.channel, itemlist)
autoplay.show_option(item.channel, itemlist)
else:
from lib import generictools
browser, res = generictools.call_browser('', lookup=True)
if not browser:
action = ''
else:
action = 'call_browser'
from channelselector import get_thumb
from core import channeltools
channel_name = channeltools.get_channel_parameters(item.channel)["title"]
itemlist.append(Item(channel=item.channel, action=action, title="Para utilizar {} se requiere Alfa Assistant. [COLOR=yellow]Haz clic para + info[/COLOR] [COLOR=green](https://alfa-addon.com/threads/manual-de-alfa-assistant-herramienta-de-apoyo.3797/)[/COLOR]".format(channel_name),
thumbnail=get_thumb("update.png"), url="https://alfa-addon.com/threads/manual-de-alfa-assistant-herramienta-de-apoyo.3797/"))
return itemlist
def filterchannels(category,preferred_thumb=""):
logger.info("channelselector.filterchannels")
channelslist =[]
# Lee la lista de canales
channel_path = os.path.join( config.get_runtime_path() , "channels" , '*.xml' )
logger.info("channelselector.filterchannels channel_path="+channel_path)
channel_files = glob.glob(channel_path)
logger.info("channelselector.filterchannels channel_files encontrados "+str(len(channel_files)))
for index, channel in enumerate(channel_files):
logger.info("channelselector.filterchannels channel="+channel)
if channel.endswith(".xml"):
try:
channel_parameters = channeltools.get_channel_parameters(channel[:-4])
logger.info("channelselector.filterchannels channel_parameters="+repr(channel_parameters))
# Si prefiere el bannermenu y el canal lo tiene, cambia ahora de idea
if preferred_thumb=="bannermenu" and "bannermenu" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["bannermenu"]
# Se salta el canal si no está activo
if not channel_parameters["active"] == "true":
continue
import xbmc
if xbmc.Player().isPlayingAudio():
xbmc.executebuiltin('xbmc.PlayMedia(Stop)')
# Si ha llegado hasta aquí, lo añade
channelslist.append(Item(title=channel_parameters["title"], channel=channel_parameters["channel"], action="mainlist", thumbnail=channel_parameters["thumbnail"] , fanart=channel_parameters["fanart"], category=", ".join(channel_parameters["categories"])[:-2], language=channel_parameters["language"], viewmode="list" ))
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel)
import traceback
logger.info(traceback.format_exc())
channelslist.sort(key=lambda item: item.title.lower().strip())
return channelslist
def get_channel_results(ch, item):
max_results = 10
results = list()
ch_params = channeltools.get_channel_parameters(ch)
try:
module = __import__('channels.%s' % ch_params["channel"],
fromlist=["channels.%s" % ch_params["channel"]])
mainlist = getattr(module,
'mainlist')(Item(channel=ch_params["channel"]))
search_action = [elem for elem in mainlist if elem.action == "search"]
if search_action:
for search_ in search_action:
try:
results.extend(module.search(search_, item.text))
except:
pass
else:
try:
results.extend(module.search(item, item.text))
except:
pass
if len(results) < 0 and len(
results) < max_results and item.mode != 'all':
if len(results) == 1:
if not results[0].action or config.get_localized_string(
30992).lower() in results[0].title.lower():
return [ch, []]
results = get_info(results)
return [ch, results]
except Exception:
import traceback
logger.error(traceback.format_exc())
return [ch, []]
def settingCanal(item):
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
list_controls = []
for infile in sorted(glob.glob(channels_path)):
channel_id = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_id)
# No incluir si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No incluir 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 incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# No incluir si en su configuracion el canal no existe 'include_in_newest'
include_in_newest = config.get_setting("include_in_newest_" + item.extra, channel_id)
if include_in_newest == "":
continue
control = {'id': channel_id,
'type': "bool",
'label': channel_parameters["title"],
'default': include_in_newest,
'enabled': True,
'visible': True}
list_controls.append(control)
caption = "Canales incluidos en Novedades " + item.title.replace("Canales incluidos en: ","- ").strip()
return platformtools.show_channel_settings(list_controls=list_controls, callback="save_settings", item=item,
caption= caption,custom_button={"visible":False})
def setting_channel(item):
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
list_controls = []
for infile in sorted(glob.glob(channels_path)):
channel_id = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_id)
# No incluir si es un canal inactivo
if not channel_parameters["active"]:
continue
# No incluir si es un canal para adultos, y el modo adulto está desactivado
if channel_parameters["adult"] and config.get_setting("adult_mode") == 0:
continue
# No incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# No incluir si en su configuracion el canal no existe 'include_in_newest'
include_in_newest = config.get_setting("include_in_newest_" + item.extra, channel_id)
if include_in_newest is None:
continue
control = {'id': channel_id,
'type': "bool",
'label': channel_parameters["title"],
'default': include_in_newest,
'enabled': True,
'visible': True}
list_controls.append(control)
caption = "Canales incluidos en Novedades " + item.title.replace("Canales incluidos en: ", "- ").strip()
return platformtools.show_channel_settings(list_controls=list_controls, callback="save_settings", item=item,
caption=caption, custom_button={"visible": False})
def get_channels(item):
logger.info()
channels_list = list()
title_list = list()
all_channels = channelselector.filterchannels('all')
for ch in all_channels:
channel = ch.channel
ch_param = channeltools.get_channel_parameters(channel)
if not ch_param.get("active", False):
continue
if ch_param.get("login_required", False):
ch_user = config.get_setting("user", channel)
ch_pass = config.get_setting("pass", channel)
if not ch_user or not ch_pass:
ch_user = config.get_setting("hdfulluser", channel)
ch_pass = config.get_setting("hdfullpassword", channel)
if not ch_user or not ch_pass:
continue
list_cat = ch_param.get("categories", [])
if not ch_param.get("include_in_global_search", False):
continue
if 'anime' in list_cat:
n = list_cat.index('anime')
list_cat[n] = 'tvshow'
if item.mode == 'all' or (item.mode in list_cat):
if config.get_setting("include_in_global_search", channel):
channels_list.append(channel)
title_list.append(ch_param.get('title', channel))
return channels_list, title_list
def settingCanal(item):
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
list_controls = []
for infile in sorted(glob.glob(channels_path)):
channel_name = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(channel_name)
# No incluir si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No incluir 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 incluir si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
# No incluir si en la configuracion del canal no existe "include_in_global_search"
include_in_global_search = config.get_setting("include_in_global_search", channel_name)
if include_in_global_search == "":
continue
control = {'id': channel_name,
'type': "bool",
'label': channel_parameters["title"],
'default': include_in_global_search,
'enabled': True,
'visible': True}
list_controls.append(control)
return platformtools.show_channel_settings(list_controls=list_controls,
caption="Canali inclusi nella ricerca globale",
callback="save_settings", item=item)
def add_extra_info(item, checks):
#logger.info()
if item.from_channel and item.channel not in ["news"]:
from core import channeltools
channel_parameters = channeltools.get_channel_parameters(
item.from_channel)
item.title = '%s [%s]' % (item.title, channel_parameters['title'])
if checks:
if "group" in checks:
check = "+"
color_check = "yellow"
elif "visto" in checks:
check = u'\u221a'
color_check = "limegreen"
item.title = "[COLOR %s][B][%s][/B][/COLOR] %s" % (color_check, check,
item.title)
return item
def menu_channels(item):
logger.info()
itemlist = list()
itemlist.append(Item(channel=CHANNELNAME, title="Activar/desactivar canales",
action="conf_tools", folder=False, extra="channels_onoff",
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Ajustes por canales",
action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
# Inicio - Canales configurables
import channelselector
from core import channeltools
channel_list = channelselector.filterchannels("all")
for channel in channel_list:
channel_parameters = channeltools.get_channel_parameters(channel.channel)
if channel_parameters["has_settings"]:
itemlist.append(Item(channel=CHANNELNAME, title=" Configuración del canal '%s'" % channel.title,
action="channel_config", config=channel.channel, folder=False,
thumbnail=channel.thumbnail))
# Fin - Canales configurables
itemlist.append(Item(channel=CHANNELNAME, action="", title="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Herramientas de canales", action="",
folder=False, thumbnail=get_thumbnail_path("thumb_canales.png")))
itemlist.append(Item(channel=CHANNELNAME, title=" Comprobar archivos *_data.json",
action="conf_tools", folder=True, extra="lib_check_datajson",
thumbnail=get_thumbnail_path("thumb_canales.png")))
return itemlist
def findvideos(item):
logger.info()
itemlist = []
if alfa_assistant.is_alfa_installed():
data = httptools.downloadpage(item.url).data
bloque = scrapertools.find_single_match(data, 'Server</span>(.*?)id="choose_quality"')
matches = scrapertools.find_multiple_matches(bloque, '<option sv="[^"]+" value="([^"]+)"')
headers = {"Referer" : item.url}
for url in matches:
xserver = scrapertools.find_single_match(url, 's=([a-zA-Z0-9]+)')
source = HOST + "get_video_info_v2?s=%s" % xserver
link = get_link(source, url)
if link:
itemlist.append(Item(channel=item.channel, action="play", url=link,
title=xserver.capitalize(),plot=item.plot, thumbnail=item.thumbnail,
contentTitle=item.title, language='VOSE', server="directo"))
#~itemlist = servertools.get_servers_itemlist(itemlist, lambda x: x.title % x.server.capitalize())
# Requerido para AutoPlay
autoplay.start(itemlist, item)
else:
from lib import generictools
browser, res = generictools.call_browser('', lookup=True)
if not browser:
action = ''
else:
action = 'call_browser'
from channelselector import get_thumb
from core import channeltools
channel_name = channeltools.get_channel_parameters(item.channel)["title"]
itemlist.append(Item(channel=item.channel, action=action, title="Para utilizar {} se requiere Alfa Assistant. [COLOR=yellow]Haz clic para + info[/COLOR] [COLOR=green](https://alfa-addon.com/threads/manual-de-alfa-assistant-herramienta-de-apoyo.3797/)[/COLOR]".format(channel_name),
thumbnail=get_thumb("update.png"), url="https://alfa-addon.com/threads/manual-de-alfa-assistant-herramienta-de-apoyo.3797/"))
return itemlist
def findvideos(item):
logger.info()
itemlist = []
soup = create_soup(item.url)
matches = soup.find_all('li', class_='OptionBx')
serv=[]
for elem in matches:
num= elem['data-key']
id= elem['data-id']
lang= elem.find('p', class_='AAIco-language').text.split()
server = elem.find('p', class_='AAIco-dns').text.strip()
# quality = elem.find('p', class_='AAIco-equalizer').text.split()
# quality = quality[-1]
lang = lang[-1]
lang = IDIOMAS.get(lang, lang)
server = SERVER.get(server, server)
url = "%s//?trembed=%s&trid=%s&trtype=1" % (host,num,id)
if not config.get_setting('unify') and not channeltools.get_channel_parameters(__channel__)['force_unify']:
title = "[%s] [COLOR darkgrey][%s][/COLOR]" %(server,lang)
else:
title = server
if not "gounlimited" in server:
itemlist.append(item.clone(action="play", title=title, url=url, server=server, language=lang ))
itemlist.sort(key=lambda it: (it.language))
# Requerido para FilterTools
itemlist = filtertools.get_links(itemlist, item, list_language)
# Requerido para AutoPlay
autoplay.start(itemlist, item)
if config.get_videolibrary_support() and len(itemlist) > 0 and item.extra !='findvideos' and not "/episodios/" in item.url :
itemlist.append(item.clone(action="add_pelicula_to_library",
title='[COLOR yellow]Añadir esta pelicula a la videoteca[/COLOR]', url=item.url,
extra="findvideos", contentTitle=item.contentTitle))
return itemlist
def lista(item):
logger.info()
itemlist = []
soup = create_soup(item.url, referer=host)
matches = soup.find_all("div", class_='card')
for elem in matches:
url = elem.a['href']
thumbnail = elem.img['src']
title = elem.find('div', class_='card-title').text.replace("en Castellano", "").strip()
title = title.split()
year = title[-2]
title = " ".join(title[1:-2])
lang = "esp"
language = []
language.append(IDIOMAS.get(lang, lang))
contentTitle = title
if year == '':
year = '-'
if not config.get_setting('unify') and not channeltools.get_channel_parameters(__channel__)['force_unify']:
if year != "-":
title = "%s [COLOR cyan](%s)[/COLOR] [COLOR darkgrey]%s[/COLOR]" % (title,year, language)
else:
title = "%s [COLOR darkgrey]%s[/COLOR]" % (title, language)
else:
title = title
itemlist.append(Item(channel=item.channel, action = "findvideos", url=url, title=title, contentTitle = contentTitle,
thumbnail=thumbnail, language=language, infoLabels={"year": year}) )
tmdb.set_infoLabels(itemlist, True)
next_page = soup.find('span', class_='is-inactive')
if next_page and next_page.find_next_sibling("a"):
next_page = next_page.find_next_sibling("a")['href']
next_page = urlparse.urljoin(item.url,next_page)
itemlist.append(item.clone(action="lista", title="[COLOR blue]Página Siguiente >>[/COLOR]", url=next_page) )
return itemlist
def lista(item):
logger.info()
itemlist = []
if item.post:
soup = get_source(api, soup=True, post=item.post)
numitem = 0
else:
soup = get_source(item.url, soup=True)
matches= soup.find_all('article')
for elem in matches:
if item.post:
numitem += 1
url = elem.a['href']
thumbnail = elem.img['src']
title = elem.h2.text.strip()
contentTitle = title
year = '-'
if not config.get_setting('unify') and not channeltools.get_channel_parameters(__channel__)['force_unify']:
if year != "-":
title = "%s [COLOR cyan](%s)[/COLOR]" % (title,year)
else:
title = title
itemlist.append( Item(channel=item.channel, action = "findvideos", url = url, title=title, contentTitle = contentTitle,
thumbnail=thumbnail, infoLabels={"year": year}))
tmdb.set_infoLabels(itemlist, True)
next_page = soup.find('a', class_='nextpostslink')
if next_page:
next_page = next_page['href']
next_page = urlparse.urljoin(item.url,next_page)
itemlist.append(item.clone(action="lista", title="[COLOR blue]Página Siguiente >>[/COLOR]", url=next_page) )
elif item.post and numitem == 18:
next_page = scrapertools.find_single_match(item.post, "&paged=(\d+)")
next_page = int(next_page) + 1
next_page = re.sub(r"&paged=\d+", "&paged={0}".format(next_page), item.post)
itemlist.append(item.clone(action="lista", title="[COLOR blue]Página Siguiente >>[/COLOR]", post=next_page) )
return itemlist
def mainlist(item):
logger.info()
itemlist = list()
itemlist.append(Item(channel=CHANNELNAME, title="Preferenze", action="settings", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion.png")))
itemlist.append(Item(channel=CHANNELNAME, title="", action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Impostazioni speciali", action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion.png")))
itemlist.append(Item(channel="novedades", title=" Impostazioni 'Novità'", action="menu_opciones",
folder=True, thumbnail=get_thumbnail_path("thumb_novedades.png")))
itemlist.append(Item(channel="buscador", title=" Impostazioni della ricerca globale", action="opciones", folder=True,
thumbnail=get_thumbnail_path("thumb_buscar.png")))
if config.get_library_support():
itemlist.append(Item(channel="biblioteca", title=" Impostazioni libreria",
action="channel_config", folder=True,
thumbnail=get_thumbnail_path("thumb_biblioteca.png")))
itemlist.append(Item(channel="biblioteca", action="update_biblio", folder=False,
thumbnail=get_thumbnail_path("thumb_biblioteca.png"),
title=" Recupera nuovi episodi e aggiorna la libreria"))
itemlist.append(Item(channel=CHANNELNAME, title="Avvia aggiornamenti", action="check_for_updates", folder=False))
itemlist.append(Item(channel=item.channel, action="", title="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Impostazioni canali", action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion.png")))
import channelselector
from core import channeltools
channel_list = channelselector.filterchannels("all")
for channel in channel_list:
try:
jsonchannel = channeltools.get_channel_json(channel.channel)
except:
continue
if jsonchannel.get("settings"):
setting = jsonchannel["settings"]
if type(setting) == list:
if len([s for s in setting if "id" in s and "include_in_" not in s["id"]]):
active_status = None
if config.get_setting("enabled", channel.channel):
active_status = config.get_setting("enabled", channel.channel)
else:
channel_parameters = channeltools.get_channel_parameters(channel.channel)
active_status = channel_parameters['active']
if active_status == "true":
itemlist.append(Item(channel=CHANNELNAME,
title=" Configurazione canale '%s'" % channel.title,
action="channel_config", config=channel.channel,
folder=False,
thumbnail=channel.thumbnail))
return itemlist
def do_search(item, categories=[]):
multithread = config.get_setting("multithread","buscador")
result_mode = config.get_setting("result_mode","buscador")
logger.info("pelisalacarta.channels.buscador do_search")
tecleado = item.extra
itemlist = []
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("pelisalacarta.channels.buscador channels_path="+channels_path)
channel_language = config.get_setting("channel_language")
logger.info("pelisalacarta.channels.buscador channel_language="+channel_language)
if channel_language == "":
channel_language = "all"
logger.info("pelisalacarta.channels.buscador channel_language="+channel_language)
#Para Kodi es necesario esperar antes de cargar el progreso, de lo contrario
#el cuadro de progreso queda "detras" del cuadro "cargando..." y no se le puede dar a cancelar
time.sleep(0.5)
progreso = platformtools.dialog_progress("Buscando " + tecleado,"")
channel_files = glob.glob(channels_path)
number_of_channels = len(channel_files)
searches = []
search_results = {}
start_time = time.time()
if multithread:
progreso.update(0, "Buscando %s..." % (tecleado))
for index, infile in enumerate(channel_files):
percentage = index*100/number_of_channels
basename = os.path.basename(infile)
basename_without_extension = basename[:-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 categories:
if not any(cat in channel_parameters["categories"] for cat in 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
if progreso.iscanceled(): break
#Modo Multi Thread
if multithread:
t = Thread(target=channel_search,args=[search_results, channel_parameters, tecleado])
t.setDaemon(True)
t.start()
searches.append(t)
#Modo single Thread
else:
logger.info("pelisalacarta.channels.buscador Intentado busqueda en " + basename_without_extension + " de " + tecleado)
progreso.update(percentage, "Buscando %s en %s..." % (tecleado, channel_parameters["title"]))
channel_search(search_results, channel_parameters, tecleado)
#Modo Multi Thread
if multithread :
pendent = len([a for a in searches if a.is_alive()])
while pendent:
pendent = len([a for a in searches if a.is_alive()])
percentage = (len(searches) - pendent) * 100 / len(searches)
progreso.update(percentage, "Buscando %s en %d canales..." % (tecleado, len(searches)))
if progreso.iscanceled(): break
time.sleep(0.5)
total = 0
for channel in sorted(search_results.keys()):
for search in search_results[channel]:
total+= len(search["itemlist"])
if result_mode ==0:
title = channel
if len(search_results[channel]) > 1:
title += " [" + search["item"].title.strip() + "]"
title +=" (" + str(len(search["itemlist"])) + ")"
title = re.sub("\[COLOR [^\]]+\]","",title)
title = re.sub("\[/COLOR]","",title)
extra = search["item"].extra + "{}" + search["item"].channel + "{}" + tecleado
itemlist.append(Item(title=title, channel="buscador",action="channel_result", url=search["item"].url, extra = extra, folder=True))
else:
itemlist.extend(search["itemlist"])
title="Buscando: '%s' | Encontrado: %d vídeos | Tiempo: %2.f segundos" % (tecleado,total, time.time()-start_time)
itemlist.insert(0,Item(title=title, color='yellow'))
progreso.close()
return itemlist
from core.item import Item
# Configuracion del canal
__modo_grafico__ = config.get_setting('modo_grafico', "oranline")
__perfil__ = int(config.get_setting('perfil', "oranline"))
# Fijar perfil de color
perfil = [['0xFFFFE6CC', '0xFFFFCE9C', '0xFF994D00'],
['0xFFA5F6AF', '0xFF5FDA6D', '0xFF11811E'],
['0xFF58D3F7', '0xFF2E9AFE', '0xFF2E64FE']]
color1, color2, color3 = perfil[__perfil__]
DEBUG = config.get_setting("debug")
host = "http://www.oranline.com/"
parameters = channeltools.get_channel_parameters("oranline")
viewmode_options = {0: 'movie_with_plot', 1: 'movie', 2: 'list'}
viewmode = viewmode_options[config.get_setting('viewmode', "oranline")]
def mainlist(item):
logger.info("pelisalacarta.channels.oranline mainlist")
itemlist = []
item.viewmode = viewmode
itemlist.append(item.clone(title="Películas", text_color=color2, action="",
text_blod=True))
itemlist.append(item.clone(action="peliculas", title=" Novedades", text_color=color1,
url=urlparse.urljoin(host, "ultimas-peliculas-online/"),
thumbnail="https://raw.githubusercontent.com/master-1970/resources/master/images/genres/"
"0/Directors%20Chair.png"))
def config_item(item):
"""
displays a filtered series for your setup
@param item: item
@type item: Item
"""
logger.info()
logger.info("item %s" % item.tostring())
# WE GET THE JSON DATA
dict_series = jsontools.get_node_from_file(item.from_channel, TAG_TVSHOW_FILTER)
tvshow = item.show.lower().strip()
default_lang = ''
channel_parameters = channeltools.get_channel_parameters(item.from_channel)
list_language = channel_parameters["filter_languages"]
try:
if channel_parameters["filter_languages"] != '' and len(list_language) > 0:
default_lang = list_language[1]
except:
pass
if default_lang == '':
platformtools.dialog_notification("FilterTools", "There are no defined languages")
return
else:
lang_selected = dict_series.get(tvshow, {}).get(TAG_LANGUAGE, default_lang)
list_quality = dict_series.get(tvshow, {}).get(TAG_QUALITY_ALLOWED, [x.lower() for x in item.list_quality])
# logger.info("lang selected {}".format(lang_selected))
# logger.info("list quality {}".format(list_quality))
active = True
custom_button = {'visible': False}
allow_option = False
if item.show.lower().strip() in dict_series:
allow_option = True
active = dict_series.get(item.show.lower().strip(), {}).get(TAG_ACTIVE, False)
custom_button = {'label': config.get_localized_string(60437), 'function': 'delete', 'visible': True, 'close': True}
list_controls = []
if allow_option:
active_control = {
"id": "active",
"type": "bool",
"label": config.get_localized_string(60438),
"color": "",
"default": active,
"enabled": allow_option,
"visible": allow_option,
}
list_controls.append(active_control)
language_option = {
"id": "language",
"type": "list",
"label": config.get_localized_string(60439),
# "color": "0xFFee66CC",
"default": item.list_language.index(lang_selected),
"enabled": True,
"visible": True,
"lvalues": item.list_language
}
list_controls.append(language_option)
if item.list_quality:
list_controls_calidad = [
{
"id": "textoCalidad",
"type": "label",
"label": "Calidad permitida",
"color": "0xffC6C384",
"enabled": True,
"visible": True,
},
]
for element in sorted(item.list_quality, key=str.lower):
list_controls_calidad.append({
"id": element,
"type": "bool",
"label": element,
"default": (False, True)[element.lower() in list_quality],
"enabled": True,
"visible": True,
})
# we concatenate list_controls with list_controls_quality
list_controls.extend(list_controls_calidad)
title = config.get_localized_string(60441) % (COLOR.get("selected", "auto"), item.show)
platformtools.show_channel_settings(list_controls=list_controls, callback='save', item=item,
caption=title, custom_button=custom_button)
def getchanneltypes(preferred_thumb=""):
logger.info("channelselector getchanneltypes")
# Lista de categorias
valid_types = ["vos", "torrent"]
dict_cat_lang = {'vos': config.get_localized_string(30136), 'torrent': 'Torrent'}
# Lee la lista de canales
channel_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("channelselector.getchanneltypes channel_path=" + channel_path)
channel_files = glob.glob(channel_path)
channel_language = config.get_setting("channel_language")
logger.info("channelselector.getchanneltypes channel_language=" + channel_language)
# Construye la lista de tipos
channel_types = []
for index, channel in enumerate(channel_files):
logger.info("channelselector.getchanneltypes channel=" + channel)
if channel.endswith(".xml"):
try:
channel_parameters = channeltools.get_channel_parameters(channel[:-4])
logger.info("channelselector.filterchannels channel_parameters=" + repr(channel_parameters))
# Si es un canal para adultos y el modo adulto está desactivado, se lo salta
if channel_parameters["adult"] == "true" and config.get_setting("adult_mode") == "false":
continue
# Si el canal está en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
categories = channel_parameters["categories"]
for category in categories:
logger.info("channelselector.filterchannels category=" + category)
if category not in channel_types and category in valid_types:
channel_types.append(category)
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel + traceback.format_exc())
logger.info("channelselector.getchanneltypes Encontrados:")
for channel_type in channel_types:
logger.info("channelselector.getchanneltypes channel_type=" + channel_type)
# Ahora construye el itemlist ordenadamente
itemlist = list()
itemlist.append(Item(title="Top Channels", channel="channelselector", action="filterchannels",
category="top channels", channel_type="top channels", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_topchannels.png"),
viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30122), channel="channelselector", action="filterchannels",
category="movie", channel_type="movie", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_film.png"), viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30123), channel="channelselector", action="filterchannels",
category="serie", channel_type="serie", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_series.png"), viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30124), channel="channelselector", action="filterchannels",
category="anime", channel_type="anime", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_anime.png"), viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30125), channel="channelselector", action="filterchannels",
category="documentary", channel_type="documentary", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_documentales.png"),
viewmode="movie"))
itemlist.append(Item(title="Cult", channel="channelselector", action="filterchannels",
category="cult", channel_type="cult", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "main_menu_filmontv.png"),
viewmode="movie"))
itemlist.append(Item(title="Saghe", channel="saghe", action="mainlist",
category="saghe", channel_type="saghe", thumbnail = os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_saghe.png")))
logger.info("channelselector.getchanneltypes Ordenados:")
for channel_type in valid_types:
logger.info("channelselector.getchanneltypes channel_type="+channel_type)
if channel_type in channel_types:
title = dict_cat_lang.get(channel_type, channel_type)
itemlist.append(Item(title=title, channel="channelselector", action="filterchannels", category=title,
channel_type= channel_type, viewmode="thumbnails",
thumbnail=urlparse.urljoin(get_thumbnail_path(preferred_thumb),
"thumb_canales_"+channel_type+".png")))
return itemlist
def filterchannels(category,preferred_thumb=""):
logger.info("channelselector.filterchannels")
channelslist =[]
# Lee la lista de canales
channel_path = os.path.join( config.get_runtime_path() , "channels" , '*.xml' )
logger.info("channelselector.filterchannels channel_path="+channel_path)
channel_files = glob.glob(channel_path)
logger.info("channelselector.filterchannels channel_files encontrados "+str(len(channel_files)))
channel_language = config.get_setting("channel_language")
logger.info("channelselector.filterchannels channel_language="+channel_language)
if channel_language=="":
channel_language = "all"
logger.info("channelselector.filterchannels channel_language="+channel_language)
for index, channel in enumerate(channel_files):
logger.info("channelselector.filterchannels channel="+channel)
if channel.endswith(".xml"):
try:
channel_parameters = channeltools.get_channel_parameters(channel[:-4])
logger.info("channelselector.filterchannels channel_parameters="+repr(channel_parameters))
# Si prefiere el bannermenu y el canal lo tiene, cambia ahora de idea
if preferred_thumb=="bannermenu" and "bannermenu" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["bannermenu"]
# Se salta el canal si no está activo
if not channel_parameters["active"] == "true":
continue
# Se salta el canal para adultos si el modo adultos está desactivado
if channel_parameters["adult"] == "true" and config.get_setting("adult_mode") != "true":
continue
# Se salta el canal si está en un idioma filtrado
if channel_language!="all" and channel_parameters["language"]!=config.get_setting("channel_language"):
continue
# Se salta el canal si está en una categoria filtrado
if category!="all" and category not in channel_parameters["categories"]:
continue
#Salta canales de deportes en listado all
if category == "all" and "deportes" in channel_parameters["categories"]:
continue
#Detiene la muúsica al entrar en Deportes
if category == "deportes":
import xbmc
xbmc.executebuiltin('xbmc.PlayMedia(Stop)')
print "si o que?"
# Si ha llegado hasta aquí, lo añade
channelslist.append(Item(title=channel_parameters["title"], channel=channel_parameters["channel"], action="mainlist", thumbnail=channel_parameters["thumbnail"] , fanart=channel_parameters["fanart"], category=", ".join(channel_parameters["categories"])[:-2], language=channel_parameters["language"], type=channel_parameters["type"] ))
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel)
import traceback
logger.info(traceback.format_exc())
channelslist.sort(key=lambda item: item.title.lower().strip())
if category=="all":
if config.get_setting("personalchannel5")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname5") ,action="mainlist", channel="personal5" ,thumbnail=config.get_setting("personalchannellogo5") , type="generic" ))
if config.get_setting("personalchannel4")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname4") ,action="mainlist", channel="personal4" ,thumbnail=config.get_setting("personalchannellogo4") , type="generic" ))
if config.get_setting("personalchannel3")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname3") ,action="mainlist", channel="personal3" ,thumbnail=config.get_setting("personalchannellogo3") , type="generic" ))
if config.get_setting("personalchannel2")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname2") ,action="mainlist", channel="personal2" ,thumbnail=config.get_setting("personalchannellogo2") , type="generic" ))
if config.get_setting("personalchannel")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname") ,action="mainlist", channel="personal" ,thumbnail=config.get_setting("personalchannellogo") , type="generic" ))
channel_parameters = channeltools.get_channel_parameters("tengourl")
# Si prefiere el bannermenu y el canal lo tiene, cambia ahora de idea
if preferred_thumb=="bannermenu" and "bannermenu" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["bannermenu"]
channelslist.insert( 0 , Item( title="Tengo una URL" ,action="mainlist", channel="tengourl" , thumbnail=channel_parameters["thumbnail"], type="generic" ))
return channelslist
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
import re
import sys
import urlparse
from channelselector import get_thumb
from core import channeltools
from core import config
from core import logger
from core import scrapertools
from core import servertools
from core.item import Item
from channels import filtertools
channel_xml = channeltools.get_channel_parameters("seriesblanco")
HOST = "http://seriesblanco.com/"
IDIOMAS = {'es': 'Español', 'en': 'Inglés', 'la': 'Latino', 'vo': 'VO', 'vos': 'VOS', 'vosi': 'VOSI', 'otro': 'OVOS'}
list_idiomas = [v for v in IDIOMAS.values()]
CALIDADES = ['SD', 'HDiTunes', 'Micro-HD-720p', 'Micro-HD-1080p', '1080p', '720p']
CAPITULOS_DE_ESTRENO_STR = "Capítulos de Estreno"
def mainlist(item):
logger.info()
thumb_series = get_thumb("squares", "thumb_canales_series.png")
thumb_series_az = get_thumb("squares", "thumb_canales_series_az.png")
thumb_buscar = get_thumb("squares", "thumb_buscar.png")
itemlist = []
def do_search(item):
logger.info("pelisalacarta.channels.buscador do_search")
tecleado = item.extra
itemlist = []
import os
import glob
import imp
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("pelisalacarta.channels.buscador channels_path="+channels_path)
channel_language = config.get_setting("channel_language")
logger.info("pelisalacarta.channels.buscador channel_language="+channel_language)
if channel_language == "":
channel_language = "all"
logger.info("pelisalacarta.channels.buscador channel_language="+channel_language)
show_dialog = False
progreso = None
if config.is_xbmc():
show_dialog = True
try:
import xbmcgui
progreso = xbmcgui.DialogProgressBG()
progreso.create("Buscando " + tecleado.title())
except ImportError:
xbmcgui = None
show_dialog = False
channel_files = glob.glob(channels_path)
number_of_channels = len(channel_files)
for index, infile in enumerate(channel_files):
percentage = index*100/number_of_channels
basename = os.path.basename(infile)
basename_without_extension = basename[:-4]
channel_parameters = channeltools.get_channel_parameters(basename_without_extension)
# No busca si es un canal inactivo
if channel_parameters["active"] != "true":
continue
# No busca si es un canal excluido de la busqueda global
if channel_parameters["include_in_global_search"] != "true":
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
if show_dialog:
progreso.update(percentage, ' Buscando "' + tecleado + '"', basename_without_extension)
logger.info("pelisalacarta.channels.buscador Intentado busqueda en " + basename_without_extension + " de " +
tecleado)
try:
# http://docs.python.org/library/imp.html?highlight=imp#module-imp
obj = imp.load_source(basename_without_extension, infile[:-4]+".py")
logger.info("pelisalacarta.channels.buscador cargado " + basename_without_extension + " de " + infile)
channel_result_itemlist = obj.search(Item(), tecleado)
for item in channel_result_itemlist:
item.title = item.title + "[" + basename_without_extension + "]"
item.viewmode = "list"
itemlist.extend(channel_result_itemlist)
except:
import traceback
logger.error(traceback.format_exc())
itemlist = sorted(itemlist, key=lambda Item: Item.title)
if show_dialog:
progreso.close()
return itemlist
def do_channels_search(item):
logger.info("streamondemand-pureita-master.channels.biblioteca do_channels_search")
try:
title_year = int(item.extra[0:4])
except:
title_year = 0
mostra = item.extra[4:]
tecleado = urllib.quote_plus(mostra)
itemlist = []
channels_path = os.path.join(config.get_runtime_path(), "channels", "*.xml")
logger.info("streamondemand-pureita-master.channels.buscador channels_path=" + channels_path)
channel_language = config.get_setting("channel_language")
logger.info("streamondemand-pureita-master.channels.buscador channel_language=" + channel_language)
if channel_language == "":
channel_language = "all"
logger.info("streamondemand-pureita-master.channels.buscador channel_language=" + channel_language)
if config.is_xbmc():
show_dialog = True
try:
import xbmcgui
progreso = xbmcgui.DialogProgressBG()
progreso.create(NLS_Looking_For % mostra)
except:
show_dialog = False
def worker(infile, queue):
channel_result_itemlist = []
try:
basename_without_extension = os.path.basename(infile)[:-4]
# http://docs.python.org/library/imp.html?highlight=imp#module-imp
obj = imp.load_source(basename_without_extension, infile[:-4] + ".py")
logger.info(
"streamondemand-pureita-master.channels.buscador cargado "
+ basename_without_extension
+ " de "
+ infile
)
# item.url contains search type: serie, anime, etc...
channel_result_itemlist.extend(obj.search(Item(extra=item.url), tecleado))
for local_item in channel_result_itemlist:
local_item.title = (
" [COLOR azure] "
+ local_item.title
+ " [/COLOR] [COLOR orange]su[/COLOR] [COLOR green]"
+ basename_without_extension
+ "[/COLOR]"
)
local_item.viewmode = "list"
except:
import traceback
logger.error(traceback.format_exc())
queue.put(channel_result_itemlist)
channel_files = glob.glob(channels_path)
channel_files_tmp = []
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
# No busca si es un canal excluido de la busqueda global
if channel_parameters["include_in_global_search"] != "true":
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
channel_files_tmp.append(infile)
channel_files = channel_files_tmp
result = Queue.Queue()
threads = [threading.Thread(target=worker, args=(infile, result)) for infile in channel_files]
start_time = int(time.time())
for t in threads:
t.daemon = (
True
) # NOTE: setting dameon to True allows the main thread to exit even if there are threads still running
t.start()
number_of_channels = len(channel_files)
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
if show_dialog:
progreso.update(completed_channels * 100 / number_of_channels)
try:
result_itemlist = result.get(timeout=timeout)
completed_channels += 1
except:
# Expired timeout raise an exception
break
for item in result_itemlist:
title = item.fulltitle
# If the release year is known, check if it matches the year found in the title
if title_year > 0:
year_match = re.search("\(.*(\d{4}).*\)", title)
if year_match and abs(int(year_match.group(1)) - title_year) > 1:
continue
# Clean up a bit the returned title to improve the fuzzy matching
title = re.sub(r"\(.*\)", "", title) # Anything within ()
title = re.sub(r"\[.*\]", "", title) # Anything within []
# Check if the found title fuzzy matches the searched one
if fuzz.token_sort_ratio(mostra, title) > 85:
itemlist.append(item)
if show_dialog:
progreso.close()
itemlist = sorted(itemlist, key=lambda item: item.fulltitle)
return itemlist
def filterchannels(category,preferred_thumb=""):
logger.info("channelselector.filterchannels")
channelslist =[]
# Si category = "allchannelstatus" es que estamos activando/desactivando canales
appenddisabledchannels = "false"
if category == "allchannelstatus":
category = "all"
appenddisabledchannels = "true"
# Lee la lista de canales
channel_path = os.path.join( config.get_runtime_path() , "channels" , '*.xml' )
logger.info("channelselector.filterchannels channel_path="+channel_path)
channel_files = glob.glob(channel_path)
logger.info("channelselector.filterchannels channel_files encontrados "+str(len(channel_files)))
channel_language = config.get_setting("channel_language")
logger.info("channelselector.filterchannels channel_language="+channel_language)
if channel_language=="":
channel_language = "all"
logger.info("channelselector.filterchannels channel_language="+channel_language)
for index, channel in enumerate(channel_files):
logger.info("channelselector.filterchannels channel="+channel)
if channel.endswith(".xml"):
try:
channel_parameters = channeltools.get_channel_parameters(channel[:-4])
logger.info("channelselector.filterchannels channel_parameters="+repr(channel_parameters))
# Si prefiere el bannermenu y el canal lo tiene, cambia ahora de idea
if preferred_thumb=="bannermenu" and "bannermenu" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["bannermenu"]
# Se salta el canal si no está activo y no estamos activando/desactivando los canales
channel_status = None
if config.get_setting("enabled", channel_parameters["channel"]):
channel_status = config.get_setting("enabled", channel_parameters["channel"])
else:
channel_status = channel_parameters["active"]
if channel_status != "true":
if appenddisabledchannels != "true":
continue
# Se salta el canal para adultos si el modo adultos está desactivado
if channel_parameters["adult"] == "true" and config.get_setting("adult_mode") != "true":
continue
# Se salta el canal si está en un idioma filtrado
if channel_language!="all" and channel_parameters["language"]!=config.get_setting("channel_language"):
continue
# Se salta el canal si está en una categoria filtrado
if category!="all" and category not in channel_parameters["categories"]:
continue
# Si ha llegado hasta aquí, lo añade
channelslist.append(Item(title=channel_parameters["title"], channel=channel_parameters["channel"],
action="mainlist", thumbnail=channel_parameters["thumbnail"] ,
fanart=channel_parameters["fanart"],
category=channel_parameters["title"],
language=channel_parameters["language"], viewmode="list" ))
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel)
import traceback
logger.info(traceback.format_exc())
channelslist.sort(key=lambda item: item.title.lower().strip())
if category=="all":
if config.get_setting("personalchannel5")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname5") ,action="mainlist", channel="personal5" ,thumbnail=config.get_setting("personalchannellogo5") , type="generic" ,viewmode="list" ))
if config.get_setting("personalchannel4")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname4") ,action="mainlist", channel="personal4" ,thumbnail=config.get_setting("personalchannellogo4") , type="generic" ,viewmode="list" ))
if config.get_setting("personalchannel3")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname3") ,action="mainlist", channel="personal3" ,thumbnail=config.get_setting("personalchannellogo3") , type="generic" ,viewmode="list" ))
if config.get_setting("personalchannel2")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname2") ,action="mainlist", channel="personal2" ,thumbnail=config.get_setting("personalchannellogo2") , type="generic" ,viewmode="list" ))
if config.get_setting("personalchannel")=="true":
channelslist.insert( 0 , Item( title=config.get_setting("personalchannelname") ,action="mainlist", channel="personal" ,thumbnail=config.get_setting("personalchannellogo") , type="generic" ,viewmode="list" ))
channel_parameters = channeltools.get_channel_parameters("tengourl")
# Si prefiere el bannermenu y el canal lo tiene, cambia ahora de idea
if preferred_thumb=="bannermenu" and "bannermenu" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["bannermenu"]
channelslist.insert( 0 , Item( title="[COLOR gray]Inserisci un URL[/COLOR]" ,action="mainlist", channel="tengourl" , thumbnail=channel_parameters["thumbnail"], type="generic" ,viewmode="movie" ))
return channelslist
# Canal para yaske
# http://blog.tvalacarta.info/plugin-xbmc/pelisalacarta/
#------------------------------------------------------------
import re, urllib, urlparse
from core import config
from core import logger
from core import httptools
from core import scrapertools
from core import servertools
from core import channeltools
from core import tmdb
from core.item import Item
HOST = 'http://estrenosli.org/'
parameters= channeltools.get_channel_parameters('estrenosgo')
fanart_host= parameters['fanart']
thumbnail_host= parameters['thumbnail']
color1, color2, color3 = ['0xFF58D3F7','0xFF2E64FE','0xFF0404B4']
def mainlist(item):
logger.info()
itemlist = []
item.url = HOST
item.text_color = color2
item.fanart = fanart_host
item.thumbnail = "https://github.com/master-1970/resources/raw/master/images/genres/0/Directors%20Chair.png"
itemlist.append(item.clone(title="Películas:", folder=False, text_color = color3, text_blod= True))
itemlist.append(item.clone(title=" Cartelera", action="listado", url= HOST + "descarga-0-58126-0-0-fx-1-1-.fx"))
itemlist.append(item.clone(title=" DVD-RIP", action="listado", url=HOST + "descarga-0-581210-0-0-fx-1-1.fx"))
def filterchannels(category, view="thumb_"):
logger.info()
channelslist = []
# Si category = "allchannelstatus" es que estamos activando/desactivando canales
appenddisabledchannels = False
if category == "allchannelstatus":
category = "all"
appenddisabledchannels = True
# Lee la lista de canales
channel_path = os.path.join(config.get_runtime_path(), "channels",
'*.json')
logger.info("channel_path=%s" % channel_path)
channel_files = glob.glob(channel_path)
logger.info("channel_files encontrados %s" % (len(channel_files)))
# channel_language = config.get_setting("channel_language", default="all")
channel_language = auto_filter()
logger.info("channel_language=%s" % channel_language)
for channel_path in channel_files:
logger.info("channel=%s" % channel_path)
channel = os.path.basename(channel_path).replace(".json", "")
try:
channel_parameters = channeltools.get_channel_parameters(channel)
if channel_parameters["channel"] == 'community':
continue
# si el canal no es compatible, no se muestra
if not channel_parameters["compatible"]:
continue
# Si no es un canal lo saltamos
if not channel_parameters["channel"]:
continue
logger.info("channel_parameters=%s" % repr(channel_parameters))
# Si prefiere el banner y el canal lo tiene, cambia ahora de idea
if view == "banner_" and "banner" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["banner"]
# si el canal está desactivado no se muestra el canal en la lista
if not channel_parameters["active"]:
continue
# Se salta el canal si no está activo y no estamos activando/desactivando los canales
channel_status = config.get_setting("enabled",
channel_parameters["channel"])
if channel_status is None:
# si channel_status no existe es que NO HAY valor en _data.json.
# como hemos llegado hasta aquí (el canal está activo en channel.json), se devuelve True
channel_status = True
if not channel_status:
# si obtenemos el listado de canales desde "activar/desactivar canales", y el canal está desactivado
# lo mostramos, si estamos listando todos los canales desde el listado general y está desactivado,
# no se muestra
if not appenddisabledchannels:
continue
# Se salta el canal para adultos si el modo adultos está desactivado
if channel_parameters["adult"] and config.get_setting(
"adult_mode") == 0:
continue
# Se salta el canal si está en un idioma filtrado
# Se muestran todos los canales si se elige "all" en el filtrado de idioma
# Se muestran sólo los idiomas filtrados, cast o lat
# Los canales de adultos se mostrarán siempre que estén activos
if channel_language != "all" and channel_language not in channel_parameters["language"] \
and "*" not in channel_parameters["language"]:
continue
# Se salta el canal si está en una categoria filtrado
if category != "all" and category not in channel_parameters[
"categories"]:
continue
# Si tiene configuración añadimos un item en el contexto
context = []
if channel_parameters["has_settings"]:
context.append({
"title": config.get_localized_string(70525),
"channel": "setting",
"action": "channel_config",
"config": channel_parameters["channel"]
})
channel_info = set_channel_info(channel_parameters)
# Si ha llegado hasta aquí, lo añade
channelslist.append(
Item(title=channel_parameters["title"],
channel=channel_parameters["channel"],
action="mainlist",
thumbnail=channel_parameters["thumbnail"],
fanart=channel_parameters["fanart"],
plot=channel_info,
category=channel_parameters["title"],
language=channel_parameters["language"],
viewmode="list",
context=context))
except:
logger.error(
"Se ha producido un error al leer los datos del canal '%s'" %
channel)
import traceback
logger.error(traceback.format_exc())
channelslist.sort(key=lambda item: item.title.lower().strip())
if category == "all":
channel_parameters = channeltools.get_channel_parameters('url')
# Si prefiere el banner y el canal lo tiene, cambia ahora de idea
if view == "banner_" and "banner" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["banner"]
channelslist.insert(
0,
Item(title=config.get_localized_string(60088),
action="mainlist",
channel="url",
thumbnail=channel_parameters["thumbnail"],
type="generic",
viewmode="list"))
if category in ['movie', 'tvshow']:
titles = [
config.get_localized_string(70028),
config.get_localized_string(30985),
config.get_localized_string(70559),
config.get_localized_string(60264),
config.get_localized_string(70560)
]
ids = ['popular', 'top_rated', 'now_playing', 'on_the_air']
for x in range(0, 3):
if x == 2 and category != 'movie':
title = titles[x + 1]
id = ids[x + 1]
else:
title = titles[x]
id = ids[x]
channelslist.insert(
x,
Item(channel='search',
action='discover_list',
title=title,
search_type='list',
list_type='%s/%s' % (category.replace('show', ''), id),
thumbnail=get_thumb(id + ".png")))
channelslist.insert(
3,
Item(channel='search',
action='genres_menu',
title=config.get_localized_string(30987),
type=category.replace('show', ''),
thumbnail=get_thumb("genres.png")))
return channelslist
from core import channeltools
from core import logger
from core import config
from core import scrapertools
from core.item import Item
from servers import servertools
from channelselector import get_thumbnail_path
__channel__ = "seriesblanco"
__category__ = "F"
__type__ = "generic"
__title__ = "Series Blanco"
__language__ = "ES"
channel_xml = channeltools.get_channel_parameters(__channel__)
HOST = "http://seriesblanco.com/"
IDIOMAS = {'es': 'Español', 'la': 'Latino', 'vos': 'VOS', 'vo': 'VO', 'japovose': 'VOSE', 'jp-sub': 'VOSE'}
DEBUG = config.get_setting("debug")
def isGeneric():
return True
def mainlist(item):
logger.info("pelisalacarta.seriesblanco mainlist")
thumb_series = get_thumbnail("thumb_canales_series.png")
def do_search(item, categories=[]):
multithread = config.get_setting("multithread", "buscador")
result_mode = "result_mode_%s" % config.get_setting("result_mode", "buscador")
logger.info()
tecleado = item.extra
itemlist = []
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("channels_path=%s" % channels_path)
channel_language = config.get_setting("channel_language")
logger.info("channel_language=%s" % channel_language)
if channel_language == "":
channel_language = "all"
logger.info("channel_language=%s" % channel_language)
# Para Kodi es necesario esperar antes de cargar el progreso, de lo contrario
# el cuadro de progreso queda "detras" del cuadro "cargando..." y no se le puede dar a cancelar
time.sleep(0.5)
progreso = platformtools.dialog_progress("Buscando '%s'..." % tecleado, "")
channel_files = sorted(glob.glob(channels_path), key=lambda x: os.path.basename(x))
number_of_channels = len(channel_files)
searches = []
search_results = {}
start_time = time.time()
if multithread:
progreso.update(0, "Buscando '%s'..." % tecleado)
for index, infile in enumerate(channel_files):
try:
percentage = (index * 100) / number_of_channels
basename = os.path.basename(infile)
basename_without_extension = basename[:-4]
logger.info("%s..." % basename_without_extension)
channel_parameters = channeltools.get_channel_parameters(basename_without_extension)
# No busca si es un canal inactivo
if channel_parameters["active"] != True:
logger.info("%s no incluido" % basename_without_extension)
continue
# En caso de busqueda por categorias
if categories:
if not any(cat in channel_parameters["categories"] for cat in categories):
logger.info("%s no incluido" % basename_without_extension)
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") == 0:
logger.info("%s no incluido" % basename_without_extension)
continue
# No busca si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
logger.info("%s no incluido" % basename_without_extension)
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 == True:
# Buscar en la configuracion del canal
include_in_global_search = config.get_setting("include_in_global_search", basename_without_extension)
if include_in_global_search != True:
logger.info("%s no incluido" % basename_without_extension)
continue
if progreso.iscanceled():
progreso.close()
logger.info("Busqueda cancelada")
return itemlist
# Modo Multi Thread
if multithread:
t = Thread(target=channel_search, args=[search_results, channel_parameters, tecleado],
name=channel_parameters["title"])
t.setDaemon(True)
t.start()
searches.append(t)
# Modo single Thread
else:
logger.info("Intentado busqueda en " + basename_without_extension + " de " + tecleado)
channel_search(search_results, channel_parameters, tecleado)
logger.info("%s incluido en la busqueda" % basename_without_extension)
progreso.update(percentage / 2, "Iniciada busqueda de '%s' en %s..." % (tecleado, channel_parameters["title"]))
except:
logger.error("No se puede buscar en: %s" % channel_parameters["title"])
import traceback
logger.error(traceback.format_exc())
continue
# Modo Multi Thread
# Usando isAlive() no es necesario try-except,
# ya que esta funcion (a diferencia de is_alive())
# es compatible tanto con versiones antiguas de python como nuevas
if multithread:
pendent = [a for a in searches if a.isAlive()]
while pendent:
percentage = (len(searches) - len(pendent)) * 100 / len(searches)
completed = len(searches) - len(pendent)
if len(pendent) > 5:
progreso.update(percentage, "Busqueda terminada en %d de %d canales..." % (completed, len(searches)))
else:
list_pendent_names = [a.getName() for a in pendent]
mensaje = "Buscando en %s" % (", ".join(list_pendent_names))
progreso.update(percentage, mensaje)
logger.debug(mensaje)
if progreso.iscanceled():
logger.info("Busqueda cancelada")
break
time.sleep(0.5)
pendent = [a for a in searches if a.isAlive()]
total = 0
for channel in sorted(search_results.keys()):
for search in search_results[channel]:
total += len(search["itemlist"])
title = channel
if result_mode == "result_mode_0":
if len(search_results[channel]) > 1:
title += " [" + search["item"].title.strip() + "]"
title += " (" + str(len(search["itemlist"])) + ")"
title = re.sub("\[COLOR [^\]]+\]", "", title)
title = re.sub("\[/COLOR]", "", title)
#extra = search["item"].extra + "{}" + search["item"].channel + "{}" + tecleado
itemlist.append(Item(title=title, channel="buscador", action="show_result", url=search["item"].url,
extra=search["item"].extra, folder=True, adult=search["adult"],from_action="search",
from_channel=search["item"].channel, tecleado=tecleado))
else:
title = ">> Resultados del canal %s:" % title
itemlist.append(Item(title=title, channel="buscador", action="",
folder=False, text_color="yellow"))
#itemlist.extend(search["itemlist"])
for i in search["itemlist"]:
if i.action:
itemlist.append(i.clone(from_action=i.action, from_channel=i.channel, channel="buscador",
action="show_result", adult=search["adult"]))
title = "Buscando: '%s' | Encontrado: %d vídeos | Tiempo: %2.f segundos" % (tecleado, total, time.time()-start_time)
itemlist.insert(0, Item(title=title, text_color='yellow'))
progreso.close()
return itemlist
def getchanneltypes(preferred_thumb=""):
logger.info("channelselector getchanneltypes")
# Lista de categorias
valid_types = ""
dict_cat_lang = ""
# Lee la lista de canales
channel_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("channelselector.getchanneltypes channel_path=" + channel_path)
channel_files = glob.glob(channel_path)
channel_language = config.get_setting("channel_language")
logger.info("channelselector.getchanneltypes channel_language=" + channel_language)
# Construye la lista de tipos
channel_types = []
for index, channel in enumerate(channel_files):
logger.info("channelselector.getchanneltypes channel=" + channel)
if channel.endswith(".xml"):
try:
channel_parameters = channeltools.get_channel_parameters(channel[:-4])
logger.info("channelselector.filterchannels channel_parameters=" + repr(channel_parameters))
# Si es un canal para adultos y el modo adulto está desactivado, se lo salta
if channel_parameters["adult"] == "true" and config.get_setting("adult_mode") == "false":
continue
# Si el canal está en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
continue
categories = channel_parameters["categories"]
for category in categories:
logger.info("channelselector.filterchannels category=" + category)
if category not in channel_types and category in valid_types:
channel_types.append(category)
except:
logger.info("Se ha producido un error al leer los datos del canal " + channel + traceback.format_exc())
logger.info("channelselector.getchanneltypes Encontrados:")
for channel_type in channel_types:
logger.info("channelselector.getchanneltypes channel_type=" + channel_type)
# Ahora construye el itemlist ordenadamente
itemlist = list()
itemlist.append(Item(title="Top Channels", channel="channelselector", action="filterchannels",
category="top channels", channel_type="top channels", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_topchannels.png"),
viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30122), channel="channelselector", action="filterchannels",
category="movie", channel_type="movie", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_film.png"), viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30123), channel="channelselector", action="filterchannels",
category="serie", channel_type="serie", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_series.png"), viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30124), channel="channelselector", action="filterchannels",
category="anime", channel_type="anime", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_anime.png"), viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(30125), channel="channelselector", action="filterchannels",
category="documentary", channel_type="documentary", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_documentales.png"),
viewmode="movie"))
itemlist.append(Item(title="Cult", channel="channelselector", action="filterchannels",
category="cult", channel_type="cult", thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "main_menu_filmontv.png"),
viewmode="movie"))
itemlist.append(Item(title=config.get_localized_string(50000), channel="saghe", action="mainlist",
category="saghe", channel_type="saghe", thumbnail = os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_saghe.png")))
itemlist.append( Item(title=config.get_localized_string(50001) , channel="filmontv" , action="mainlist" , thumbnail = os.path.join(config.get_runtime_path() , "resources" , "images", "main_menu_filmontv.png"),viewmode="movie") )
itemlist.append( Item(title=config.get_localized_string(50003) , channel="netflixsrc" , action="mainlist" , thumbnail = os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_series.png"),viewmode="movie") )
itemlist.append( Item( title=config.get_localized_string(30136) , channel="channelselector" , action="filterchannels" , channel_type="vos", category="vos" , thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_vos.png"),viewmode="movie") )
#itemlist.append( Item( title="Torrent" , channel="channelselector" , action="filterchannels" , channel_type="torrent", category="torrent" , thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "cat_menu_torrent.png"),viewmode="movie") )
itemlist.append( Item( title="[COLOR yellow]" + config.get_localized_string(30121) + "[/COLOR]" , channel="channelselector" , action="filterchannels" , channel_type="all", category="all" , thumbnail= os.path.join(config.get_runtime_path() , "resources" , "images", "main_menu_all.png"),viewmode="movie") )
logger.info("channelselector.getchanneltypes Ordenados:")
for channel_type in valid_types:
logger.info("channelselector.getchanneltypes channel_type="+channel_type)
if channel_type in channel_types:
title = dict_cat_lang.get(channel_type, channel_type)
itemlist.append(Item(title=title, channel="channelselector", action="filterchannels", category=title,
channel_type= channel_type, viewmode="thumbnails",
thumbnail=urlparse.urljoin(get_thumbnail_path(preferred_thumb),
"thumb_canales_"+channel_type+".png")))
return itemlist
def do_search(item):
logger.info("streamondemand.channels.saghe do_search")
tecleado = item.extra
mostra = item.fulltitle
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)
if config.is_xbmc():
show_dialog = True
try:
import xbmcgui
progreso = xbmcgui.DialogProgressBG()
progreso.create("Ricerca di " + mostra)
except:
show_dialog = False
def worker(infile, queue):
channel_result_itemlist = []
try:
basename_without_extension = os.path.basename(infile)[:-4]
# http://docs.python.org/library/imp.html?highlight=imp#module-imp
obj = imp.load_source(basename_without_extension, infile[:-4]+".py")
logger.info("streamondemand.channels.buscador cargado " + basename_without_extension + " de " + infile)
channel_result_itemlist.extend(obj.search(Item(), tecleado))
for item in channel_result_itemlist:
item.title = " [COLOR azure] " + item.title + " [/COLOR] [COLOR orange]su[/COLOR] [COLOR green]" + basename_without_extension + "[/COLOR]"
item.viewmode = "list"
except:
import traceback
logger.error(traceback.format_exc())
queue.put(channel_result_itemlist)
channel_files = glob.glob(channels_path)
channel_files_tmp = []
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
# No busca si es un canal excluido de la busqueda global
if channel_parameters["include_in_global_search"] != "true":
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
channel_files_tmp.append(infile)
channel_files = channel_files_tmp
result = Queue.Queue()
threads = [threading.Thread(target=worker, args=(infile, result)) for infile in channel_files]
for t in threads:
t.start()
number_of_channels = len(channel_files)
for index, t in enumerate(threads):
percentage = index * 100 / number_of_channels
if show_dialog:
progreso.update(percentage, ' Sto cercando "' + mostra + '"')
t.join()
itemlist.extend(result.get())
itemlist = sorted([item for item in itemlist if fuzz.WRatio(mostra, item.fulltitle) > 85],
key=lambda Item: Item.title)
if show_dialog:
progreso.close()
return itemlist
def do_search(item, categories=[]):
multithread = config.get_setting("multithread", "buscador")
result_mode = config.get_setting("result_mode", "buscador")
logger.info()
tecleado = item.extra
itemlist = []
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.xml')
logger.info("channels_path=%s" % channels_path)
channel_language = config.get_setting("channel_language")
logger.info("channel_language=%s" % channel_language)
if channel_language == "":
channel_language = "all"
logger.info("channel_language=%s" % channel_language)
# Para Kodi es necesario esperar antes de cargar el progreso, de lo contrario
# el cuadro de progreso queda "detras" del cuadro "cargando..." y no se le puede dar a cancelar
time.sleep(0.5)
progreso = platformtools.dialog_progress("Buscando '%s'..." % tecleado, "")
channel_files = sorted(glob.glob(channels_path), key=lambda x: os.path.basename(x))
number_of_channels = len(channel_files)
searches = []
search_results = {}
start_time = time.time()
if multithread:
progreso.update(0, "Buscando '%s'..." % tecleado)
for index, infile in enumerate(channel_files):
try:
percentage = (index * 100) / number_of_channels
basename = os.path.basename(infile)
basename_without_extension = basename[:-4]
logger.info("%s..." % basename_without_extension)
channel_parameters = channeltools.get_channel_parameters(basename_without_extension)
# No busca si es un canal inactivo
if channel_parameters["active"] != "true":
logger.info("%s no incluido" % basename_without_extension)
continue
# En caso de busqueda por categorias
if categories:
if not any(cat in channel_parameters["categories"] for cat in categories):
logger.info("%s no incluido" % basename_without_extension)
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") == "0":
logger.info("%s no incluido" % basename_without_extension)
continue
# No busca si el canal es en un idioma filtrado
if channel_language != "all" and channel_parameters["language"] != channel_language:
logger.info("%s no incluido" % basename_without_extension)
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 in ["", "true"]:
# Buscar en la configuracion del canal
include_in_global_search = str(config.get_setting("include_in_global_search", basename_without_extension))
# Si no hay valor en la configuración del canal se incluye ya que así estaba por defecto
'''if include_in_global_search == "":
include_in_global_search = "true"'''
if include_in_global_search.lower() != "true":
logger.info("%s no incluido" % basename_without_extension)
continue
if progreso.iscanceled():
progreso.close()
logger.info("Busqueda cancelada")
return itemlist
# Modo Multi Thread
if multithread:
t = Thread(target=channel_search, args=[search_results, channel_parameters, tecleado],
name=channel_parameters["title"])
t.setDaemon(True)
t.start()
searches.append(t)
# Modo single Thread
else:
logger.info("Intentado busqueda en " + basename_without_extension + " de " + tecleado)
channel_search(search_results, channel_parameters, tecleado)
logger.info("%s incluido en la busqueda" % basename_without_extension)
progreso.update(percentage / 2, "Iniciada busqueda de '%s' en %s..." % (tecleado, channel_parameters["title"]))
except:
continue
logger.error("No se puede buscar en: %s" % channel_parameters["title"])
import traceback
logger.error(traceback.format_exc())
# Modo Multi Thread
# Usando isAlive() no es necesario try-except,
# ya que esta funcion (a diferencia de is_alive())
# es compatible tanto con versiones antiguas de python como nuevas
if multithread:
pendent = [a for a in searches if a.isAlive()]
while pendent:
percentage = (len(searches) - len(pendent)) * 100 / len(searches)
completed = len(searches) - len(pendent)
if len(pendent) > 5:
progreso.update(percentage, "Busqueda terminada en %d de %d canales..." % (completed, len(searches)))
else:
list_pendent_names = [a.getName() for a in pendent]
mensaje = "Buscando en %s" % (", ".join(list_pendent_names))
progreso.update(percentage, mensaje)
logger.debug(mensaje)
if progreso.iscanceled():
logger.info("Busqueda cancelada")
break
time.sleep(0.5)
pendent = [a for a in searches if a.isAlive()]
total = 0
for channel in sorted(search_results.keys()):
for search in search_results[channel]:
total += len(search["itemlist"])
title = channel
if result_mode == 0:
if len(search_results[channel]) > 1:
title += " [" + search["item"].title.strip() + "]"
title += " (" + str(len(search["itemlist"])) + ")"
title = re.sub("\[COLOR [^\]]+\]", "", title)
title = re.sub("\[/COLOR]", "", title)
extra = search["item"].extra + "{}" + search["item"].channel + "{}" + tecleado
itemlist.append(Item(title=title, channel="buscador", action="channel_result", url=search["item"].url,
extra=extra, folder=True))
else:
title = ">> Resultados del canal %s:" % title
itemlist.append(Item(title=title, channel="buscador", action="",
folder=False, text_color="yellow"))
itemlist.extend(search["itemlist"])
# itemlist.append(Item(title="", channel="buscador", action="", folder=False))
title = "Buscando: '%s' | Encontrado: %d vídeos | Tiempo: %2.f segundos" % (tecleado, total, time.time()-start_time)
itemlist.insert(0, Item(title=title, text_color='yellow'))
progreso.close()
return itemlist
def do_search(item):
logger.info("streamondemand.channels.buscador do_search")
tecleado = item.extra
mostra = item.fulltitle
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)
if config.is_xbmc():
show_dialog = True
try:
import xbmcgui
progreso = xbmcgui.DialogProgressBG()
progreso.create("Ricerca di " + mostra)
except:
show_dialog = False
def worker(infile, queue):
channel_result_itemlist = []
try:
basename_without_extension = os.path.basename(infile)[:-4]
# http://docs.python.org/library/imp.html?highlight=imp#module-imp
obj = imp.load_source(basename_without_extension,
infile[:-4] + ".py")
logger.info("streamondemand.channels.buscador cargado " +
basename_without_extension + " de " + infile)
channel_result_itemlist.extend(
obj.search(Item(extra='movie'), tecleado))
for item in channel_result_itemlist:
item.title = " [COLOR azure] " + item.title + " [/COLOR] [COLOR orange]su[/COLOR] [COLOR orange]" + basename_without_extension + "[/COLOR]"
item.viewmode = "list"
except:
import traceback
logger.error(traceback.format_exc())
queue.put(channel_result_itemlist)
channel_files = glob.glob(channels_path)
channel_files_tmp = []
for infile in channel_files:
basename_without_extension = os.path.basename(infile)[:-4]
channel_parameters = channeltools.get_channel_parameters(
basename_without_extension)
# Non cercare se il canale e inattivo
if channel_parameters["active"] != "true":
continue
# Non Cercare se in canale e escluso dalla ricerca globale
if channel_parameters["include_in_global_search"] != "true":
continue
# Non cercare se il canale e per adulti e se la modalita adulti e disabilitata
if channel_parameters["adult"] == "true" and config.get_setting(
"adult_mode") == "false":
continue
# Non cercare se il canale e in una lingua filtrata
if channel_language != "all" and channel_parameters[
"language"] != channel_language:
continue
channel_files_tmp.append(infile)
channel_files = channel_files_tmp
result = Queue.Queue()
threads = [
threading.Thread(target=worker, args=(infile, result))
for infile in channel_files
]
start_time = int(time.time())
for t in threads:
t.daemon = True # NOTE: setting dameon to True allows the main thread to exit even if there are threads still running
t.start()
number_of_channels = len(channel_files)
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
if show_dialog:
progreso.update(completed_channels * 100 / number_of_channels)
try:
result_itemlist = result.get(timeout=timeout)
completed_channels += 1
except:
# Expired timeout raise an exception
break
for item in result_itemlist:
title = item.fulltitle
# Clean up a bit the returned title to improve the fuzzy matching
title = re.sub(r'\(.*\)', '', title) # Anything within ()
title = re.sub(r'\[.*\]', '', title) # Anything within []
# Check if the found title fuzzy matches the searched one
if fuzz.WRatio(mostra, title) > 85: itemlist.append(item)
if show_dialog:
progreso.close()
itemlist = sorted(itemlist, key=lambda item: item.fulltitle)
return itemlist
def conf_tools(item):
logger.info()
# Activar o desactivar canales
if item.extra == "channels_onoff":
import channelselector
from core import channeltools
channel_list = channelselector.filterchannels("allchannelstatus")
channel_language = config.get_setting("channel_language")
if channel_language == "":
channel_language = "all"
excluded_channels = ['tengourl',
'buscador',
'libreria',
'configuracion',
'novedades',
'personal',
'ayuda',
'descargas']
list_controls = []
try:
list_controls.append({'id': "all_channels",
'type': "list",
'label': "Todos los canales",
'default': 0,
'enabled': True,
'visible': True,
'lvalues': ['',
'Activar todos',
'Desactivar todos',
'Establecer estado por defecto']})
for channel in channel_list:
# Si el canal esta en la lista de exclusiones lo saltamos
if channel.channel not in excluded_channels:
# Se cargan los ajustes del archivo json del canal
jsonchannel = channeltools.get_channel_json(channel.channel)
if jsonchannel.get("settings") or jsonchannel.get("active"):
channel_parameters = channeltools.get_channel_parameters(channel.channel)
# No incluir si es un canal para adultos, y el modo adulto está desactivado
if (channel_parameters["adult"] == "true" and
config.get_setting("adult_mode") == "0"):
continue
# No incluir si el canal es en un idioma filtrado
if (channel_language != "all" and
channel_parameters["language"] != channel_language):
continue
status = None
xml_status = channel_parameters["active"].replace("t", "T").replace("f", "F")
xml_status = eval(xml_status)
if config.get_setting("enabled", channel.channel):
status = config.get_setting("enabled", channel.channel)
status = status.replace("t", "T").replace("f", "F")
status = eval(status)
# logger.info(channel.channel + " | Status: " + str(status))
else:
status = xml_status
# logger.info(channel.channel + " | Status (XML): " + str(status))
status_control = ""
if not xml_status:
status_control = " [COLOR grey](Desactivado por defecto)[/COLOR]"
if status is not None:
control = {'id': channel.channel,
'type': "bool",
'label': channel_parameters["title"] + status_control,
'default': status,
'enabled': True,
'visible': True}
list_controls.append(control)
else:
logger.info("Algo va mal con el canal " + channel.channel)
else:
continue
return platformtools.show_channel_settings(list_controls=list_controls,
caption="Canales",
callback="channel_status",
custom_button={"visible": False})
except:
import traceback
logger.info(channel.title + " | Detalle del error: %s" % traceback.format_exc())
platformtools.dialog_notification("Error",
"Se ha producido un error con el canal %s" %
channel.title)
# Comprobacion de archivos channel_data.json
elif item.extra == "lib_check_datajson":
itemlist = []
import channelselector
from core import channeltools
channel_list = channelselector.filterchannels("allchannelstatus")
# Tener una lista de exclusion no tiene mucho sentido por que se comprueba si
# el xml tiene "settings", pero por si acaso se deja
excluded_channels = ['tengourl',
'configuracion',
'personal',
'ayuda']
try:
import os
from core import jsontools
for channel in channel_list:
needsfix = None
list_status = None
list_controls = None
default_settings = None
channeljson_exists = None
# Se convierte el "channel.channel" del canal biblioteca para que no de error
if channel.channel == "libreria":
channel.channel = "biblioteca"
# Se comprueba si el canal esta en la lista de exclusiones
if channel.channel not in excluded_channels:
# Se comprueba que tenga "settings", sino se salta
jsonchannel = channeltools.get_channel_json(channel.channel)
if not jsonchannel.get("settings"):
itemlist.append(Item(channel=CHANNELNAME,
title=channel.title + " - No tiene ajustes por defecto",
action="", folder=False,
thumbnail=channel.thumbnail))
continue
# logger.info(channel.channel + " SALTADO!")
# Se cargan los ajustes del archivo json del canal
file_settings = os.path.join(config.get_data_path(), "settings_channels",
channel.channel + "_data.json")
dict_settings = {}
dict_file = {}
if filetools.exists(file_settings):
# logger.info(channel.channel + " Tiene archivo _data.json")
channeljson_exists = "true"
# Obtenemos configuracion guardada de ../settings/channel_data.json
try:
dict_file = jsontools.load_json(open(file_settings, "rb").read())
if isinstance(dict_file, dict) and 'settings' in dict_file:
dict_settings = dict_file['settings']
except EnvironmentError:
logger.info("ERROR al leer el archivo: %s" % file_settings)
else:
# logger.info(channel.channel + " No tiene archivo _data.json")
channeljson_exists = "false"
if channeljson_exists == "true":
try:
datajson_size = filetools.getsize(file_settings)
except:
import traceback
logger.info(channel.title +
" | Detalle del error: %s" % traceback.format_exc())
else:
datajson_size = None
# Si el _data.json esta vacio o no existe...
if (len(dict_settings) and datajson_size) == 0 or channeljson_exists == "false":
# Obtenemos controles del archivo ../channels/channel.xml
needsfix = "true"
try:
# Se cargan los ajustes por defecto
list_controls, default_settings = channeltools.get_channel_controls_settings(channel.channel)
# logger.info(channel.title + " | Default: %s" % default_settings)
except:
import traceback
logger.info(channel.title + " | Detalle del error: %s" % traceback.format_exc())
# default_settings = {}
# Si _data.json necesita ser reparado o no existe...
if needsfix == "true" or channeljson_exists == "false":
if default_settings is not None:
# Creamos el channel_data.json
default_settings.update(dict_settings)
dict_settings = default_settings
dict_file['settings'] = dict_settings
# Creamos el archivo ../settings/channel_data.json
json_data = jsontools.dump_json(dict_file)
try:
open(file_settings, "wb").write(json_data)
# logger.info(channel.channel + " - Archivo _data.json GUARDADO!")
# El channel_data.json se ha creado/modificado
list_status = " - [COLOR red] CORREGIDO!![/COLOR]"
except EnvironmentError:
logger.info("ERROR al salvar el archivo: %s" % file_settings)
else:
if default_settings is None:
list_status = " - [COLOR red] Imposible cargar los ajustes por defecto![/COLOR]"
else:
# logger.info(channel.channel + " - NO necesita correccion!")
needsfix = "false"
# Si se ha establecido el estado del canal se añade a la lista
if needsfix is not None:
if needsfix == "true":
if channeljson_exists == "false":
list_status = " - Ajustes creados"
list_colour = "red"
else:
list_status = " - No necesita correccion"
list_colour = "green"
else:
# Si "needsfix" es "false" y "datjson_size" es None habra
# ocurrido algun error
if datajson_size is None:
list_status = " - Ha ocurrido algun error"
list_colour = "red"
else:
list_status = " - No necesita correccion"
list_colour = "green"
if list_status is not None:
itemlist.append(Item(channel=CHANNELNAME,
title=channel.title + list_status,
action="", folder=False,
thumbnail=channel.thumbnail,
text_color=list_colour))
else:
logger.info("Algo va mal con el canal %s" % channel.channel)
# Si el canal esta en la lista de exclusiones lo saltamos
else:
continue
except:
import traceback
logger.info(channel.title + " | Detalle del error: %s" % traceback.format_exc())
platformtools.dialog_notification("Error",
"Se ha producido un error con el canal %s" %
channel.title)
return itemlist
else:
platformtools.dialog_notification("pelisalacarta", "Error!")
platformtools.itemlist_update(Item(channel=CHANNELNAME, action="submenu_tools"))
import sys
import urlparse
from time import sleep
from core import channeltools
from core import httptools
from core import jsontools
from core import scrapertools
from core import servertools
from core.item import Item
from platformcode import config, logger
from platformcode import platformtools
host = 'https://www.megadede.com'
__channel__ = 'megadede'
parameters = channeltools.get_channel_parameters(__channel__)
fanart_host = parameters['fanart']
thumbnail_host = parameters['thumbnail']
color1, color2, color3 = ['0xFFB10021', '0xFFB10021', '0xFFB10004']
def login():
url_origen = host + "/login?popup=1"
try:
data = httptools.downloadpage(url_origen).data
except:
data = httptools.downloadpage(url_origen, follow_redirects=False).data
if '<span class="username">' in data:
return True
token = scrapertools.find_single_match(
data, '<input name="_token" type="hidden" value="([^"]+)"')
def mainlist(item):
logger.info()
itemlist = list()
itemlist.append(Item(channel=CHANNELNAME, title="Preferencias", action="settings", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
if config.get_setting("plugin_updates_available") == "0":
nuevas = ""
elif config.get_setting("plugin_updates_available") == "1":
nuevas = " (1 nueva)"
else:
nuevas = " (" + config.get_setting("plugin_updates_available") + " nuevas)"
thumb_configuracion = "thumb_configuracion_" + config.get_setting("plugin_updates_available") + ".png"
itemlist.append(Item(channel=CHANNELNAME, title="Descargar e instalar otras versiones" + nuevas,
action="get_all_versions", folder=True,
thumbnail=get_thumbnail_path(thumb_configuracion)))
itemlist.append(Item(channel=CHANNELNAME, title="", action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Ajustes especiales", action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel="novedades", title=" Ajustes de la sección 'Novedades'", action="menu_opciones",
folder=True, thumbnail=get_thumbnail_path("thumb_novedades.png")))
itemlist.append(Item(channel="buscador", title=" Ajustes del buscador global", action="opciones", folder=True,
thumbnail=get_thumbnail_path("thumb_buscar.png")))
itemlist.append(Item(channel=CHANNELNAME, title=" Ajustes de descargas", action="channel_config", config="descargas", folder=True,
thumbnail=get_thumbnail_path("thumb_descargas.png")))
if config.get_library_support():
itemlist.append(Item(channel="biblioteca", title=" Ajustes de la biblioteca",
action="channel_config", folder=True,
thumbnail=get_thumbnail_path("thumb_biblioteca.png")))
itemlist.append(Item(channel="biblioteca", action="update_biblio", folder=False,
thumbnail=get_thumbnail_path("thumb_biblioteca.png"),
title=" Buscar nuevos episodios y actualizar biblioteca"))
itemlist.append(Item(channel=CHANNELNAME, title=" Añadir o Actualizar canal/conector desde una URL",
action="menu_addchannels"))
itemlist.append(Item(channel=CHANNELNAME, action="", title="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Activar/desactivar canales",
action="conf_tools", folder=False, extra="channels_onoff",
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Ajustes por canales",
action="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
# Inicio - Canales configurables
import channelselector
from core import channeltools
channel_list = channelselector.filterchannels("all")
for channel in channel_list:
channel_parameters = channeltools.get_channel_parameters(channel.channel)
if channel_parameters["has_settings"]:
itemlist.append(Item(channel=CHANNELNAME, title=" Configuración del canal '%s'" % channel.title,
action="channel_config", config=channel.channel, folder=False,
thumbnail=channel.thumbnail))
# Fin - Canales configurables
itemlist.append(Item(channel=CHANNELNAME, action="", title="", folder=False,
thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
itemlist.append(Item(channel=CHANNELNAME, title="Otras herramientas", action="submenu_tools",
folder=True, thumbnail=get_thumbnail_path("thumb_configuracion_0.png")))
return itemlist
