def get_menu(item, json, key, itemlist=[]):
support.info()
json = json[key]
for option in json:
title = option['title'] if 'title' in option else json[option] if 'search' not in option else ''
extra = set_extra_values(item, option, item.path)
level2 = option if 'level2' in option else []
it = Item(channel = item.channel,
title = support.typo(title, 'bullet bold'),
fulltitle = title,
show = title,
url = extra.url,
path = item.path,
thumbnail = extra.thumb,
fanart = extra.fanart,
plot = extra.plot,
action = 'show_menu',
menu = level2 if not item.menu else None,
filterkey = extra.filterkey,
filter = extra.filter)
if title:
itemlist.append(it)
if 'search' in option:
get_search_menu(it, json, itemlist)
elif 'submenu' in option:
get_sub_menu(it, option, 'submenu' ,itemlist)
for item in itemlist:
if not item.thumbnail: support.thumb(item)
return itemlist
def select(item):
support.info()
itemlist = []
# support.dbg()
if type(item.url) in [list, dict]:
json = item.url
else:
json = current_session.get(item.url).json()
if 'blocks' in json:
json = json['blocks']
season = ''
for key in json:
if item.fulltitle in key['name']:
season = key['name'].replace(item.fulltitle, '').strip()
if not season.isdigit(): season = ''
itemlist.append(
item.clone(title=support.typo(key['name'], 'bold'),
season=season,
url=key['sets'],
action='select'))
if len(itemlist) == 1:
return select(itemlist[0])
else:
for key in item.url:
itemlist.append(
item.clone(title=support.typo(key['name'], 'bold'),
data=getUrl(key['path_id']),
url=getUrl(key['path_id']),
contentType='tvshow',
action='episodios'))
if len(itemlist) == 1:
return episodios(itemlist[0])
return itemlist
def submenu(item):
support.info()
itemlist = []
json = current_session.get(item.url).json()['contents'][-1]['contents']
if item.args == 'az':
json_url = getUrl(json[-1]['path_id'])
json = current_session.get(json_url).json()['contents']
for key in json:
itemlist.append(
item.clone(title=support.typo(key, 'bold'),
fulltitle=key,
show=key,
url=json[key],
action='peliculas'))
else:
for key in json:
itemlist.append(
item.clone(title=support.typo(key['name'], 'bold'),
fulltitle=key['name'],
show=key['name'],
thumbnail=getUrl(key['image']),
url=getUrl(key['path_id']),
action='peliculas'))
itemlist.pop(-1)
return support.thumb(itemlist)
def itemHook(item):
for value, season in seasons:
info(value)
info(season)
item.title = item.title.replace(value + 'x', season + 'x')
item.url += '\n' + item.other
return item
def replay_menu(item):
support.info()
import datetime, xbmc
# create day and month list
days = []
months = []
days.append(xbmc.getLocalizedString(17))
for day in range(11, 17):
days.append(xbmc.getLocalizedString(day))
for month in range(21, 33):
months.append(xbmc.getLocalizedString(month))
# make menu
itemlist = []
today = datetime.date.today()
for d in range(7):
day = today - datetime.timedelta(days=d)
support.info(day)
itemlist.append(
item.clone(
action='replay_channels',
date=day.strftime("%d-%m-%Y"),
title=support.typo(
days[int(day.strftime("%w"))] + " " + day.strftime("%d") +
" " + months[int(day.strftime("%m")) - 1], 'bold')))
return itemlist
def newest(categoria):
support.info(categoria)
itemlist = []
item = support.Item()
item.url = host
item.action = 'peliculas'
try:
if categoria == 'peliculas':
item.contentType = 'movie'
itemlist = peliculas(item)
else:
item.args = 'last'
item.contentType = 'tvshow'
itemlist = peliculas(item)
if itemlist[-1].action == 'peliculas':
itemlist.pop()
# Continua la ricerca in caso di errore
except:
import sys
for line in sys.exc_info():
support.infoger.error("%s" % line)
return []
return itemlist
def news(item):
support.info()
item.contentType = 'episode'
itemlist = []
import cloudscraper
session = cloudscraper.create_scraper()
fullJs = json.loads(
support.match(session.get(item.url).text,
headers=headers,
patron=r'items-json="([^"]+)"').match.replace(
'"', '"'))
js = fullJs['data']
for it in js:
itemlist.append(
item.clone(title=support.typo(
it['anime']['title'] + ' - EP. ' + it['number'], 'bold'),
fulltitle=it['anime']['title'],
thumbnail=it['anime']['imageurl'],
forcethumb=True,
scws_id=it.get('scws_id', ''),
video_url=it.get('link', ''),
plot=it['anime']['plot'],
action='findvideos'))
if 'next_page_url' in fullJs:
itemlist.append(
item.clone(title=support.typo(
support.config.get_localized_string(30992), 'color kod bold'),
thumbnail=support.thumb(),
url=fullJs['next_page_url']))
return itemlist
def live(item):
support.info()
itemlist = []
json = current_session.get(item.url).json()['entries']
for it in json:
urls = []
if it['tuningInstruction'] and not it['mediasetstation$digitalOnly']:
guide=current_session.get('https://static3.mediasetplay.mediaset.it/apigw/nownext/' + it['callSign'] + '.json').json()['response']
if 'restartUrl' in guide['currentListing']:
urls = [guide['currentListing']['restartUrl']]
else:
for key in it['tuningInstruction']['urn:theplatform:tv:location:any']:
urls += key['publicUrls']
plot = support.typo(guide['currentListing']['mediasetlisting$epgTitle'],'bold') + '\n' + guide['currentListing']['mediasetlisting$shortDescription'] + '\n' + guide['currentListing']['description'] + '\n\n' + support.typo('A Seguire:' + guide['nextListing']['mediasetlisting$epgTitle'], 'bold')
itemlist.append(item.clone(title=support.typo(it['title'], 'bold'),
fulltitle=it['title'],
show=it['title'],
contentTitle=it['title'],
thumbnail=it['thumbnails']['channel_logo-100x100']['url'],
forcethumb=True,
urls=urls,
plot=plot,
action='play',
no_return=True))
return support.thumb(itemlist, live=True)
def episodios(item):
support.info()
itemlist = []
episode = ''
json = current_session.get('https://feed.entertainment.tv.theplatform.eu/f/PR1GhC/mediaset-prod-all-programs?byCustomValue={subBrandId}{' + item.url + '}').json()['entries']
for it in json:
urls = []
if 'media' in it:
for key in it['media']:
urls.append(key['publicUrl'])
if urls:
title = it['title'].split('-')[-1].strip()
if it['tvSeasonNumber'] and it['tvSeasonEpisodeNumber']:
item.infoLabels['season'] = it['tvSeasonNumber']
item.infoLabels['episode'] = it['tvSeasonEpisodeNumber']
episode = '%dx%02d - ' % (it['tvSeasonNumber'], it['tvSeasonEpisodeNumber'])
itemlist.append(
item.clone(action='findvideos',
title=support.typo(episode + title, 'bold'),
contentType='episode',
thumbnail=it['thumbnails']['image_vertical-264x396']['url'] if 'image_vertical-264x396' in it['thumbnails'] else '',
fanart=it['thumbnails']['image_keyframe_poster-1280x720']['url'] if 'image_keyframe_poster-1280x720' in it['thumbnails'] else '',
plot=it['longDescription'] if 'longDescription' in it else it['description'],
urls=urls,
url=it['mediasetprogram$pageUrl']))
if episode:
itemlist = sorted(itemlist, key=lambda it: it.title)
support.videolibrary(itemlist, item)
return itemlist
def news(item):
support.info()
item.contentType = 'tvshow'
itemlist = []
fullJs = json.loads(
support.match(item, headers=headers,
patron=r'items-json="([^"]+)"').match.replace(
'"', '"'))
js = fullJs['data']
for it in js:
itemlist.append(
support.Item(channel=item.channel,
title=support.typo(
it['anime']['title'] + ' - EP. ' + it['number'],
'bold'),
fulltitle=it['anime']['title'],
server='directo',
thumbnail=it['anime']['imageurl'],
forcethumb=True,
url=it['link'],
plot=it['anime']['plot'],
action='play'))
if 'next_page_url' in fullJs:
itemlist.append(
item.clone(title=support.typo(
support.config.get_localized_string(30992), 'color kod bold'),
thumbnail=support.thumb(),
url=fullJs['next_page_url']))
return itemlist
def mainlist(item):
support.info()
itemlist = [
Item(title=support.typo('Film in onda oggi', 'bold'),
channel=item.channel,
action='category',
contentType='movie',
thumbnail=support.thumb('movie')),
Item(title=support.typo('Serie Tv in onda oggi', 'bold'),
channel=item.channel,
action='peliculas',
contentType='tvshow',
thumbnail=support.thumb('tvshow')),
Item(title=support.typo('Guida tv per canale', 'bold'),
channel=item.channel,
action='listaCanali',
thumbnail=support.thumb('on_the_air')),
Item(title=support.typo('Canali live', 'bold'),
channel=item.channel,
action='live',
thumbnail=support.thumb('tvshow_on_the_air'))
]
return itemlist
def findvideos(item):
info()
matches = support.match(item,
patron=[
r'class="metaframe rptss" src="([^"]+)"',
r' href="#option-\d">([^\s]+)\s*([^\s]+)'
]).matches
itemlist = []
list_url = []
list_quality = []
list_servers = []
for match in matches:
if type(match) == tuple:
list_servers.append(match[0])
list_quality.append(match[1])
else:
if 'player.php' in match:
match = support.httptools.downloadpage(
match, follow_redirect=True).url
list_url.append(match)
for i, url in enumerate(list_url):
itemlist.append(
support.Item(channel=item.channel,
title=list_servers[i],
url=url,
action='play',
quality=list_quality[i],
infoLabels=item.infoLabels))
return support.server(item, itemlist=itemlist)
def mainlist(item):
support.info(item)
film = [
'/film/', ('Generi', ['', 'genres', 'genres']),
('Per Lettera', ['/film-a-z/', 'genres', 'letter']),
('Anni', ['', 'genres', 'year']),
('Popolari', ['/trending/?get=movies', 'peliculas', 'populared']),
('Più Votati', ['/ratings/?get=movies', 'peliculas', 'populared'])
]
tvshow = [
'/serie/',
('Aggiornamenti', ['/aggiornamenti-serie/', 'peliculas', 'update']),
('Popolari', ['/trending/?get=tv', 'peliculas', 'populared']),
('Più Votati', ['/ratings/?get=tv', 'peliculas', 'populared'])
]
anime = ['/anime/']
Tvshow = [('Show TV {bullet bold}',
['/tv-show/', 'peliculas', '', 'tvshow'])]
search = ''
return locals()
def newest(categoria):
info(categoria)
itemlist = []
item = Item()
if categoria == 'peliculas':
item.contentType = 'movie'
item.url = host + '/film/'
elif categoria == 'series':
item.args = 'update'
item.contentType = 'tvshow'
item.url = host + '/aggiornamenti-serie/'
## elif categoria == 'anime':
## item.contentType = 'tvshow'
## item.url = host + '/anime/'
try:
item.action = 'peliculas'
itemlist = peliculas(item)
except:
import sys
for line in sys.exc_info():
info("{0}".format(line))
return []
return itemlist
def addinfo(key, item):
support.info()
info = current_session.get(getUrl(key['info_url'])).json() if 'info_url' in key else {}
if 'images' in key:
fanart = key['images']['landscape']
if key['images']['portrait_logo']:
thumb = key['images']['portrait_logo']
else:
thumb = key['images']['landscape']
else:
thumb = ''
fanart = ''
it = item.clone(title=support.typo(key.get('name', ''), 'bold'), fulltitle=key.get('name', ''),
show=key.get('name', ''), data='', thumbnail=getUrl(thumb),
fanart=getUrl(fanart), url=getUrl(key['path_id']), plot=info.get('description', ''))
if 'Genere' not in key.get('sub_type', '') and ('layout' not in key or key['layout'] == 'single'):
it.action = 'findvideos'
it.contentType = 'movie'
it.contentTitle = it.fulltitle
else:
it.action = 'select'
it.contentType = 'tvshow'
it.contentSerieName = it.fulltitle
return it
def search(item, texto):
info(texto)
itemlist = []
try:
patron = r'<li class="cat-item cat-item-\d+"><a href="([^"]+)"\s?>([^<]+)</a>'
matches = support.match(item, patron=patron, headers=headers).matches
for i, (scrapedurl, scrapedtitle) in enumerate(matches):
if texto.upper() in scrapedtitle.upper():
scrapedthumbnail = ""
scrapedplot = ""
title = cleantitle(scrapedtitle)
itemlist.append(
item.clone(action="episodios",
title=title,
url=scrapedurl,
thumbnail=scrapedthumbnail,
fulltitle=title,
show=title,
plot=scrapedplot,
contentType='episode',
originalUrl=scrapedurl))
tmdb.set_infoLabels_itemlist(itemlist, seekTmdb=True)
except:
import sys
for line in sys.exc_info():
support.info('search log:', line)
return []
return itemlist
def newest(categoria):
itemlist = []
item = support.Item()
item.args = 'newest'
try:
if categoria == 'series':
item.contentType = 'tvshow'
item.url = host + '/aggiornamenti-serie-tv'
else:
item.contentType = 'movie'
item.url = host + '/category/film'
item.action = 'peliculas'
itemlist = peliculas(item)
if itemlist[-1].action == 'peliculas':
itemlist.pop()
# Continua la ricerca in caso di errore
except:
import sys
for line in sys.exc_info():
support.info("%s" % line)
return []
return itemlist
def findvideos(item):
itemlist = []
support.info()
# support.dbg()
matches = support.match(item, patron=r'href="([^"]+)"', patronBlock=r'<div style="white-space: (.*?)<div id="main-content"')
if not matches.matches and item.contentType != 'episode':
item.data = matches.data
item.contentType = 'tvshow'
return episodios(item)
if 'vvvvid' in matches.data:
itemlist.append(item.clone(action="play", title='VVVVID', url=support.match(matches.data, patron=r'(http://www.vvvvid[^"]+)').match, server='vvvvid'))
else:
# matches.matches.sort()
support.info('VIDEO')
for url in matches.matches:
lang = url.split('/')[-2]
if 'ita' in lang.lower():
language = 'ITA'
if 'sub' in lang.lower():
language = 'Sub-' + language
quality = url.split('/')[-1].split('?')[0]
url += '|User-Agent=' + support.httptools.get_user_agent() + '&Referer=' + url
itemlist.append(item.clone(action="play", title=language, url=url, contentLanguage = language, quality = quality, order = quality.replace('p','').zfill(4), server='directo',))
itemlist.sort(key=lambda x: (x.title, x.order), reverse=False)
return support.server(item, itemlist=itemlist)
def check(item):
support.info()
data = support.match(item.url, headers=headers).data
if data:
blockAnime = support.match(
data,
patron=
r'<div id="container" class="container">(.+?<div style="margin-left)'
).match
if support.match(
blockAnime,
patron=r'\d+(?:×|×)?\d+\-\d+|\d+(?:×|×)\d+').match:
item.contentType = 'tvshow'
item.data = data
return episodios(item)
elif blockAnime and ('episodio' in blockAnime.lower()
or 'saga' in blockAnime.lower()):
item.contentType = 'tvshow'
item.args = 'anime'
item.data = blockAnime
return episodios(item)
else:
item.contentType = 'movie'
item.data = data
return findvideos(item)
def newest(categoria):
support.info()
itemlist = []
item = Item()
try:
if categoria == "peliculas":
item.url = host + "/category/film/"
item.action = "peliculas"
item.extra = "movie"
item.contentType = 'movie'
itemlist = peliculas(item)
else:
item.url = host + "/aggiornamenti-serie-tv/"
item.action = "peliculas"
item.args = "newest"
item.contentType = 'tvshow'
itemlist = peliculas(item)
# Continua la ricerca in caso di errore
except:
import sys
for line in sys.exc_info():
support.info("{0}".format(line))
return []
return itemlist
def findvideos(item):
info(item)
if item.args != 'update':
return support.server(item, data=item.url)
else:
itemlist = []
item.infoLabels['mediatype'] = 'episode'
data = support.match(item).data
urls_video = support.match(
data,
patron=r'<a data-id="[^"]+" data-(href=".*?)</iframe>').matches[-1]
url_serie = support.match(
data, patron=r'<link rel="canonical" href="([^"]+)"\s?/>').match
itemlist = support.server(item, data=urls_video)
itemlist.append(
item.clone(title=support.typo(
"Vai alla Serie Completa: " + item.fulltitle, ' bold'),
contentType='tvshow',
url=url_serie,
action='episodios',
thumbnail=support.thumb('tvshow')))
return itemlist
def peliculas(item):
support.info()
# debug = True
if item.args != 'newest':
patronBlock = r'<ul class="posts">(?P<block>.*)<\/ul>'
patron = r'<li><a href="(?P<url>[^"]+)" data-thumbnail="(?P<thumb>[^"]+)">.*?<div class="title">(?P<title>.+?)(?:\[(?P<lang>Sub-ITA)\])?(?:[ ]\[?(?P<quality>[HD]+)?\])?(?:[ ]\((?P<year>\d+)\)?)?<\/div>'
patronNext = r'<a href="([^"]+)" >Pagina'
else:
patronBlock = r'<ul class="posts">(?P<block>.*)<div class="clear">'
patron = r'<li>\s?<a href="(?P<url>[^"]+)" data-thumbnail="(?P<thumb>[^"]+)">.*?<div class="title">(?P<title>.+?)(?:\s\[(?P<quality>HD)\])?<\/div><div class="episode"[^>]+>(?P<episode>[^<(]+)(?:\((?P<lang>[a-zA-Z\-]+)\))?'
pagination = ''
if item.args == 'search':
action = 'select'
elif item.contentType == 'tvshow':
action = 'episodios'
elif item.contentType == 'movie':
action = 'findvideos'
else:
action = 'select'
def itemHook(item):
item.title = item.title.replace(r'-', ' ')
return item
return locals()
def live(item):
itemlist = []
urls = []
matches = support.match(
host, patron=r'(/diretta-tv/[^"]+)"[^>]+>([^ ]+)').matches
from datetime import date
today = date.today()
channels = jsontools.load(
support.match(host + '/api/more/tvschedule/' + str(today.year) +
str(today.month) + str(today.day)).data)['channels']
ch_dict = {}
for channel in channels:
ch_dict[channel['label']] = channel['channelId']
for url, title in matches:
if url not in urls:
urls.append(url)
info = jsontools.load(
support.match(host + '/api/on-air?channelId=' +
ch_dict[title]).data)
support.info(info)
plot = '[B]' + info['seriesTitle'] + '[/B]\n' + info[
'description'] if 'seriesTitle' in info else ''
itemlist.append(
item.clone(title=support.typo(title, 'bold'),
contentTitle=title,
url=host + url,
plot=plot,
action='findvideos'))
return itemlist
def newest(categoria):
support.info(categoria)
itemlist = []
item = support.Item()
try:
if categoria == "peliculas":
item.url = host + '/category/films'
item.contentType = 'movies'
return peliculas(item)
if categoria == "series":
item.url = host + '/category/serie'
item.contentType = 'tvshow'
return peliculas(item)
if categoria == "anime":
item.url = host + '/category/anime-cartoni-animati'
item.contentType = 'tvshow'
return peliculas(item)
# Continua la ricerca in caso di errore
except:
import sys
for line in sys.exc_info():
support.infoger.error("{0}".format(line))
return []
return itemlist
def live(item):
support.info()
itemlist = []
info = {}
json = current_session.get(item.url).json()['dirette']
onAir = current_session.get(onair).json()['on_air']
support.info(onAir)
for key in onAir:
channel = key['channel']
info[channel] = {}
info[channel]['fanart'] = getUrl(key['currentItem']['image'])
info[channel]['plot'] = support.typo(
key['currentItem']['name'],
'bold') + '\n\n' + key['currentItem']['description']
for i, key in enumerate(json):
channel = key['channel']
itemlist.append(
item.clone(title=support.typo(channel, 'bold'),
fulltitle=channel,
show=channel,
url=key['video']['contentUrl'],
thumbnail=key['transparent-icon'].replace(
"[RESOLUTION]", "256x-"),
forcethumb=True,
fanart=info[channel]['fanart'],
plot=info[channel]['plot'],
action='play',
no_return=True))
return support.thumb(itemlist, live=True)
def live(item):
support.info()
itemlist =[]
for channel, value in liveDict().items():
itemlist.append(item.clone(title = support.typo(channel, 'bold'), fulltitle = channel, show = channel, url = value['url'],
plot = value['plot'], action = 'play', fanart = value['fanart'], manifest='hls', no_return=True))
return support.thumb(itemlist, live=True)
def load_episodes(key, item):
support.info()
itemlist = []
json = current_session.get(getUrl(key['path_id'])).json()['items']
order = 0
for key in json:
ep = support.match(key['subtitle'],
patron=r'(?:St\s*(\d+))?\s*Ep\s*(\d+)').match
if ep:
season = '1' if not ep[0] else ep[0]
episode = ep[1].zfill(2)
title = season + 'x' + episode + support.re.sub(
r'(?:St\s*\d+)?\s*Ep\s*\d+', '', key['subtitle'])
order = int(season + episode)
else:
title = key['subtitle'].strip()
if not title:
title = key['name']
itemlist.append(
item.clone(title=support.typo(title, 'bold'),
url=key['video_url'],
contentType='episode',
fanart=getUrl(key['images']['landscape']),
plot=key['description'],
action='findvideos',
VL=True if ep else False,
order=order))
return itemlist
def episodios(item):
support.info()
itemlist = []
if type(item.data) in [list, dict] and len(item.data) > 1 and ('name' in item.data[0] and 'stagione' not in item.data[0]['name'].lower()):
for key in item.data:
itemlist.append(item.clone(title = support.typo(key['name'], 'bold'), url = getUrl(key['path_id']), contentType = 'tvshow', action = 'episodios'))
elif type(item.data) in [list, dict]:
for key in item.data:
load_episodes(key, item)
with futures.ThreadPoolExecutor() as executor:
itlist = [executor.submit(load_episodes, key, item) for key in item.data]
for res in futures.as_completed(itlist):
if res.result():
itemlist += res.result()
if itemlist and itemlist[0].VL:
# itemlist.reverse()
itemlist = sorted(itemlist, key=lambda it: it.order)
item.action = 'episodios'
support.videolibrary(itemlist, item)
else:
itemlist = sorted(itemlist, key=lambda it: it.title)
else:
date = ''
if type(item.data) in [list, dict]: item.data = getUrl(item.url[0]['path_id'])
json = current_session.get(item.url).json()['items']
for key in json:
ep = support.match(key['subtitle'], patron=r'(?:St\s*(\d+))?\s*Ep\s*(\d+)').match
if ep:
season = '1' if not ep[0] else ep[0]
episode = ep[1].zfill(2)
title = support.re.sub(r'(?:St\s*\d+)?\s*Ep\s*\d+','',key['subtitle'])
title = season + 'x' + episode + (' - ' + title if not title.startswith(' ') else title if title else '')
elif item.season and support.match(item.title.lower(), patron =r'(puntate)').match:
title = key['subtitle'].strip()
if not title: title = key['name']
date = support.match(title, patron=r'(\d+/\d+/\d+)').match
if date:
date = title.split('/')
date = date[2][-2] + '/' + date[1] + '/' + date[0]
else:
title = key['subtitle'].strip()
if not title:
title = key['name']
itemlist.append(item.clone(title = support.typo(title, 'bold'), action = 'findvideos', VL=True if ep else False, plot = key['description'],
fanart = getUrl(key['images']['landscape']), url = key['video_url'], contentType = 'episode', date=date))
if item.season and support.match(item.title.lower(), patron =r'(puntate)').match:
itemlist = sorted(itemlist, key=lambda it: it.date)
for i, it in enumerate(itemlist):
episode = str(i + 1)
it.title = support.typo(item.season + 'x' + episode, 'bold') + (' - ' + it.title)
if itemlist and itemlist[0].VL: support.videolibrary(itemlist, item)
if itemlist and not support.match(itemlist[0].title, patron=r'[Ss]?(\d+)(?:x|_|\.|\s+)[Ee]?[Pp]?(\d+)').match and inspect.stack()[1][3] not in ['find_episodes']:
autorenumber.start(itemlist, item)
return itemlist
def findvid_serie(item):
def load_vid_series(html, item, itemlist, blktxt):
support.info('HTML', html)
# Estrae i contenuti
matches = support.match(
html,
patron=r'<a href=(?:")?([^ "]+)[^>]+>(?!<!--)(.*?)(?:</a>|<img)'
).matches
for url, server in matches:
item = item.clone(action="play",
title=server,
url=url,
server=server,
quality=blktxt)
if 'swzz' in item.url: item.url = support.swzz_get_url(item)
itemlist.append(item)
support.info()
itemlist = []
data = re.sub(r'((?:<p>|<strong>)?[^\d]*\d*(?:×|×)[0-9]+[^<]+)',
'', item.url)
# Blocks with split
blk = re.split(r"(?:>\s*)?([A-Za-z\s0-9]*):\s*<", data, re.S)
blktxt = ""
for b in blk:
if b[0:3] == "a h" or b[0:4] == "<a h":
load_vid_series("<%s>" % b, item, itemlist, blktxt)
blktxt = ""
elif len(b.strip()) > 1:
blktxt = b.strip()
return support.server(item, itemlist=itemlist)
def findvideos(item):
support.info('findvideos', item)
return support.server(
item,
support.match(item,
patron='<ul class="playernav">.*?</ul>',
headers=headers).match)
