def PLAYMEDIA(name,url):
ok = True
r = re.findall(r'(.+?)\[COLOR', name)
name = r[0]
r=re.findall('Season(.+?)Episode([^<]+)',name)
if r:
infoLabels =main.GETMETAEpiT(name,'','')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
else:
infoLabels =main.GETMETAT(name,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(url)
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(name+' '+'[COLOR=FF67cc33]TvRelease[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=str(img), fanart=str(fanart), is_folder=False)
player.KeepAlive()
return ok
except:
return ok
def LINKFX(name,murl):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
main.GA("FXCine","Watched")
stream_url = False
ok=True
infoLabels =main.GETMETAT(name,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
url=getlink(murl)
stream_url = main.resolve_url(url)
try:
listitem = xbmcgui.ListItem(thumbnailImage='')
listitem.setInfo('video', {'Title': name, 'Year': ''} )
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=infoLabels['title'],season=season, episode=episode, year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(name+' '+'[COLOR green]FXCine[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img='', fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKMOO(mname,murl,thumb):
main.GA("Mooviemaniac","Watched")
ok=True
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Opening Link,5000)")
infoLabels =main.GETMETAT(mname,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
try:
stream_url = main.resolve_url(murl)
if stream_url == False:
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre'], 'originaltitle': infoLabels['metaName']}
# play with bookmark
stream_url=stream_url.replace(' ','%20')
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
wh.add_item(mname+' '+'[COLOR green]"Mooviemaniac"[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKVD(name,murl,thumb):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
main.GA("Video Documentaire","Watched")
stream_url = False
ok=True
link=main.OPENURL(murl)
try:
match=re.compile('''<iframe.+?src="(.+?)".+?</iframe>''',re.DOTALL).findall(link)[0]
if 'http:' not in match:
match='http:'+match
stream_url = main.resolve_url(match.replace('?rel=0',''))
except:xbmc.executebuiltin("XBMC.Notification(Sorry!,Link Removed or Dead,3000)")
try:
listitem = xbmcgui.ListItem(thumbnailImage=thumb)
listitem.setInfo('video', {'Title': name, 'Year': ''} )
infoL={'Title': name, 'Plot': '', 'Genre': ''}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='', title=name,season='', episode='', year='',img=thumb,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(name+' '+'[COLOR green]Video Documentaire[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infoL, img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKFS(name,murl):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,5000)")
main.GA("SokroStream","Watched")
stream_url = False
ok=True
infoLabels =main.GETMETAT(name,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
if 'frenchstream'in murl:
murl=GetLink(murl)
stream_url = main.resolve_url(murl)
print stream_url
try:
listitem = xbmcgui.ListItem(thumbnailImage=img)
listitem.setInfo('video', {'Title': name, 'Year': ''} )
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=infoLabels['title'],season=season, episode=episode, year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(name+' '+'[COLOR green]SokroStream[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=img, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def PLAYLINK(mname,murl):
name=main.removeColoredText(mname)
murl = murl.lstrip('ice')
murl = eval(urllib.unquote(murl))
murl = resolveIceLink(murl)
main.GA("IceFilms","Watched")
ok=True
infoLabels =main.GETMETAT(mname,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(murl)
infoL={'Title': name, 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=name,season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
wh.add_item(mname+' '+'[COLOR green]IceFilms[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKTV4B(mname,murl):
main.GA("RlsmixTV","Watched")
ok=True
infoLabels =main.GETMETAEpiT(mname,'','')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(murl)
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=infoLabels['title'],season=str(season), episode=(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Rlsmix[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def PLAYLINK(mname, murl):
name = main.removeColoredText(mname)
main.GA("IceFilms", "Watched")
ok = True
infoLabels = main.GETMETAT(mname, '', '', '')
video_type = 'movie'
season = ''
episode = ''
img = infoLabels['cover_url']
fanart = infoLabels['backdrop_url']
imdb_id = infoLabels['imdb_id']
murl = resolveIceLink(murl)
infolabels = {
'supports_meta': 'true',
'video_type': video_type,
'name': str(infoLabels['title']),
'imdb_id': str(infoLabels['imdb_id']),
'season': str(season),
'episode': str(episode),
'year': str(infoLabels['year'])
}
try:
xbmc.executebuiltin(
"XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(murl)
infoL = {
'Title': name,
'Plot': infoLabels['plot'],
'Genre': infoLabels['genre']
}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(
resolved_url=stream_url,
addon_id=addon_id,
video_type=video_type,
title=name,
season=str(season),
episode=str(episode),
year=str(infoLabels['year']),
img=img,
infolabels=infoL,
watchedCallbackwithParams=main.WatchedCallbackwithParams,
imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
wh.add_item(mname + ' ' + '[COLOR green]IceFilms[/COLOR]',
sys.argv[0] + sys.argv[2],
infolabels=infolabels,
img=img,
fanart=fanart,
is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINK(name,murl,thumb):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,5000)")
main.GA("Yify","Watched")
stream_url = False
ok=True
infoLabels =main.GETMETAT(name,'','',thumb)
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
stream_url = main.resolve_url(murl)
try:
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre'], 'originaltitle': infoLabels['metaName']}
# play with bookmark
from resources.universal import playbackengine
if stream_url: main.CloseAllDialogs()
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=infoLabels['title'],season=season, episode=episode, year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(name+' '+'[COLOR green]Yify[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=img, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINK(name, murl, thumb):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,5000)")
main.GA("Yify", "Watched")
stream_url = False
ok = True
infoLabels = main.GETMETAT(name, '', '', thumb)
video_type = 'movie'
season = ''
episode = ''
img = infoLabels['cover_url']
fanart = infoLabels['backdrop_url']
imdb_id = infoLabels['imdb_id']
infolabels = {
'supports_meta': 'true',
'video_type': video_type,
'name': str(infoLabels['title']),
'imdb_id': str(infoLabels['imdb_id']),
'season': str(season),
'episode': str(episode),
'year': str(infoLabels['year'])
}
stream_url = main.resolve_url(murl)
try:
infoL = {
'Title': infoLabels['title'],
'Plot': infoLabels['plot'],
'Genre': infoLabels['genre'],
'originaltitle': infoLabels['metaName']
}
# play with bookmark
from resources.universal import playbackengine
if stream_url: main.CloseAllDialogs()
player = playbackengine.PlayWithoutQueueSupport(
resolved_url=stream_url,
addon_id=addon_id,
video_type=video_type,
title=infoLabels['title'],
season=season,
episode=episode,
year=str(infoLabels['year']),
img=img,
infolabels=infoL,
watchedCallbackwithParams=main.WatchedCallbackwithParams,
imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(name + ' ' + '[COLOR green]Yify[/COLOR]',
sys.argv[0] + sys.argv[2],
infolabels='',
img=img,
fanart='',
is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINK(mname,murl,thumb,desc):
link=main.OPENURL(murl)
link=main.unescapes(link)
ok=True
try:
match=re.compile('src="http://www.youtube.com/embed/(.+?).?autoplay=1&cc_load_policy=0.+?"').findall(link)
if match:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Opening Link,3000)")
stream_url = "plugin://plugin.video.youtube/?path=/root/video&action=play_video&videoid="+match[0]+"&hd=1"
match2=re.compile('src="http://player.vimeo.com/video/(.+?)"').findall(link)
if match2:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(str('http://vimeo.com/'+match2[0]))
if(stream_url == False):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Link Cannot Be Resolved,5000)")
return
infoL={'Title': mname, 'Plot': desc}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='', title=mname,season='', episode='', year='',img=thumb,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Doc-Wire[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
else:
xbmc.executebuiltin("XBMC.Notification(Sorry!,Link deleted Or unplayable,5000)")
return ok
def NovaWeed(murl):
link=main.OPENURL(murl)
link=main.unescapes(link)
vw = re.compile('flashvars.advURL="(.+?)";').findall(link)
vid_url=vw[0]
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
return main.resolve_url(vid_url)
def LINKSCINEM(mname,murl,thumb,desc):
main.GA("MailRu","Watched")
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,5000)")
link=main.OPENURL(murl)
ok=True
match = re.compile('<iframe src="(.+?)"').findall(link)
if match:
stream_url = main.resolve_url(match[0])
try:
if stream_url == False: return
infoL={'Title': mname, 'Plot': desc, 'Genre': '', 'originaltitle': mname}
# play with bookmark
stream_url=stream_url.replace(' ','%20')
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='', title=mname,season='', episode='', year='',img=thumb,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory(addon_id)
#wh.add_item(mname+' '+'[COLOR green]MAILRU[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return True
except Exception, e:
if stream_url != False: main.ErrorReport(e)
return False
def PLAYOCW(mname,murl):
sources=[]
main.GA("OneclickwatchT","Watched")
ok=True
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting Hosts,5000)")
link=main.OPENURL(murl)
link=link.replace('\r','').replace('\n','').replace('\t','').replace(' ','')
match=re.compile('<p><a href=".+?" rel=".+?">(.+?)</a></p>').findall(link)
desc=re.compile('<.+? />Plot:(.+?)<.+? />').findall(link)
if len(desc)>0:
descs=desc[0]
else:
descs=''
thumb=re.compile('<img alt="" src="(.+?)"').findall(link)
if len(thumb)>0:
thumbs=thumb[0]
else:
thumbs=''
main.CloseAllDialogs()
import urlresolver
for url in match:
host=re.compile("http://(.+?).com/.+?").findall(url)
for hname in host:
host=hname.replace('www.','')
hosted_media = urlresolver.HostedMediaFile(url=url, title=host)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
try:
if source:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
else:
stream_url = False
return
infoLabels =main.GETMETAEpiT(mname,thumbs,descs)
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Oneclickwatch[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except:
return ok
def LINKFX(name, murl):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
main.GA("FXCine", "Watched")
stream_url = False
ok = True
infoLabels = main.GETMETAT(name, "", "", "")
video_type = "movie"
season = ""
episode = ""
img = infoLabels["cover_url"]
fanart = infoLabels["backdrop_url"]
imdb_id = infoLabels["imdb_id"]
infolabels = {
"supports_meta": "true",
"video_type": video_type,
"name": str(infoLabels["title"]),
"imdb_id": str(infoLabels["imdb_id"]),
"season": str(season),
"episode": str(episode),
"year": str(infoLabels["year"]),
}
url = getlink(murl)
stream_url = main.resolve_url(url)
try:
listitem = xbmcgui.ListItem(thumbnailImage="")
listitem.setInfo("video", {"Title": name, "Year": ""})
infoL = {"Title": infoLabels["title"], "Plot": infoLabels["plot"], "Genre": infoLabels["genre"]}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(
resolved_url=stream_url,
addon_id=addon_id,
video_type=video_type,
title=infoLabels["title"],
season=season,
episode=episode,
year=str(infoLabels["year"]),
img=img,
infolabels=infoL,
watchedCallbackwithParams=main.WatchedCallbackwithParams,
imdb_id=imdb_id,
)
# WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(
name + " " + "[COLOR green]FXCine[/COLOR]",
sys.argv[0] + sys.argv[2],
infolabels="",
img="",
fanart="",
is_folder=False,
)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def VIDEOLINKSSG(mname,murl,thumb):
#main.GA("SG","Watched")
msg = xbmcgui.DialogProgress()
msg.create('Please Wait!','')
msg.update(0,'Collecting hosts')
sources = []
ok=True
infoLabels =main.GETMETAEpiT(mname,thumb,'')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
link=main.OPENURL(murl)
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
link=link.replace('\r','').replace('\n','').replace('\t','').replace(' ','').replace(' ','')
match=re.compile('href="([^"]+)"><img src=".+?" /><span class="link_name_tt">([^<]+)</span>').findall(link)
hostsmax = len(match)
h = 0
import urlresolver
for url, host in sorted(match):
host=host.replace('Visit ','')
h += 1
percent = (h * 100)/hostsmax
msg.update(percent,'Collecting hosts - ' + str(percent) + '%')
if (msg.iscanceled()): break
hosted_media = urlresolver.HostedMediaFile(url=url, title=host)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
return
else:
source = urlresolver.choose_source(sources)
msg.close()
try:
if not source:
main.CloseAllDialogs()
return
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if stream_url == False: return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
wh.add_item(mname+' '+'[COLOR green]SeriesGate[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKWATCHS(mname,murl):
main.GA("Watchseries","Watched")
ok=True
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
match=re.compile('(.+?)xocx(.+?)xocx').findall(murl)
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Checking Link,3000)")
for hurl, durl in match:
furl=geturl('http://watchseries.lt'+hurl)
link=main.OPENURL(durl)
link=link.replace('\r','').replace('\n','').replace('\t','').replace(' ','')
match2=re.compile('<h1 class=".+?"><a href=".+?">.+?</a> - <a href="(.+?)" title=".+?">.+?</a>').findall(link)
for xurl in match2:
link2=main.OPENURL('http://watchseries.lt'+xurl)
link2=link2.replace('\r','').replace('\n','').replace('\t','').replace(' ','')
descr=re.compile('<b>Description :</b>(.+?)<').findall(link2)
if len(descr)>0:
desc=descr[0]
else:
desc=''
thumbs=re.compile('<td style=".+?"><a href=".+?"><img src="(.+?)"').findall(link2)
if len(thumbs)>0:
thumb=thumbs[0]
else:
thumb=''
genres=re.compile('<b>Genre: <a href=.+?>(.+?)</a>').findall(link2)
if len(genres)>0:
genre=genres[0]
else:
genre=''
infoLabels =main.GETMETAEpiT(mname,thumb,desc)
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(furl)
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
wh.add_item(mname+' '+'[COLOR green]WatchSeries[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def VIDEOLINKSEXTRA(mname,murl,thumb,desc):
main.GA("Extramina","Watched")
sources = []
link=main.OPENURL(murl)
ok=True
infoLabels =main.GETMETAT(mname,'','',thumb)
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting hosts,5000)")
match=re.compile('<div class="streamlink"><a target=".+?" href="(.+?)">(.+?)</a></div>').findall(link)
for url, host in match:
match3=re.compile('extraminamovies').findall(url)
if len(match3)>0:
link2=main.OPENURL(url)
match = re.compile('<iframe src="(.+?)"').findall(link2)
if len(match)==0:
match = re.compile('src="(.+?)"').findall(link2)
for url in match:
match2=re.compile('http://(.+?)/.+?').findall(url)
for host in match2:
host = host.replace('www.','')
if host =='putlocker.com':
url=url.replace('embed','file')
hosted_media = urlresolver.HostedMediaFile(url=url, title=host)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Extramina[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKFMA(mname,murl,thumb,desc):
main.GA("FMA","Watched")
sources = []
ok=True
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting hosts,3000)")
infoLabels =main.GETMETAT(mname,'','',thumb)
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
link=main.OPENURL(murl)
link=link.replace('\r','').replace('\n','').replace('\t','').replace(' ','')
match=re.compile('<span class=\'.+?\'>(.+?)</span></p><div class=\'.+?\'><img src=\'.+?\' /></div><a class=\'.+?\' href="(.+?)"').findall(link)
import urlresolver
for host, url in match:
durl='http://www.freemoviesaddict.com/'+url
redirect=main.REDIRECT(durl)
hosted_media = urlresolver.HostedMediaFile(url=redirect, title=host)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
if source != False:
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(mname+' '+'[COLOR green]FMA[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def resolveMBLink(url):
try:
r = re.findall('h=(\d+?)&u=(\d+?)&y=(\d+)',url,re.I)
if r: r = int(r[0][0]) + int(r[0][1]) + int(r[0][2])
else: r = 537 + int(re.findall('id=(\d+)',url,re.I)[0])
link=main.OPENURL(url,verbose=False)
q = re.findall('"lang":"en","apple":(\d+?),"google":(\d+?),"microsoft":"([^"]+?)"',link,re.I)
vklink = "https://vk.com/video_ext.php?oid="+str(r + int(q[0][0]))+"&id="+str(r + int(q[0][1]))+"&hash="+q[0][2]
except:
vklink=url
vklink=vklink.replace("\/",'/')
stream_url = main.resolve_url(vklink)
return stream_url
def VIDEOLINKST2(mname,murl,thumb):
sources = []
main.GA("Movie1k","Watched")
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting Hosts,10000)")
f = re.findall('(.+?) Season (.+?) Episode ([^<]+)',mname,re.I)
if f:
infoLabels =main.GETMETAEpiT(mname,thumb,'')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
if len(f)==0:
infoLabels =main.GETMETAT(mname,'','',thumb)
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
link=main.OPENURL(murl)
link=link.replace('\r','').replace('\n','').replace('\t','').replace(' ','')
ok=True
match=re.compile('<td >([^<]+)</td><td ><a href="http://www.movie1k.ag/watch.php.?idl=(.+?)"',re.DOTALL).findall(link)
for host,url in match:
hosted_media = urlresolver.HostedMediaFile(url=url, title=host)
sources.append(hosted_media)
try:
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Movie1k[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def CHANNELCLink(mname,murl):
main.GA("CC/Tv4","Watched")
sources = []
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting hosts,3000)")
link=main.OPENURL(murl)
ok=True
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
site = re.findall('channelcut',murl)
if len(site)>0:
match=re.compile('<a href="(.+?)" rel="nofollow">.+?</a><br/>').findall(link)
else:
match=re.compile('<td><a href="(.+?)" target="').findall(link)
for url in match:
match2=re.compile('http://(.+?)/.+?').findall(url)
for host in match2:
host = host.replace('www.','')
hosted_media = urlresolver.HostedMediaFile(url=url, title=host)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoLabels =main.GETMETAEpiT(mname,'','')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]CC/Tv4[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=img, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def ViceLink(mname,murl,thumb2):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Playing Link,5000)")
link=main.OPENURL(murl)
ok=True
desci=re.compile('<meta name="description" content="(.+?)" />').findall(link)
if len(desci)>0: desc=desci[0]
else: desc=''
thumbi=re.compile('<meta property="og:image" content="(.+?)" />').findall(link)
if len(thumbi)>0: thumb=thumbi[0]
else: thumb=''
match=re.compile('content="http://player.ooyala.com/player.swf.?embedCode=(.+?)&').findall(link)
if len(match)>0:
durl='http://player.ooyala.com/player/ipad/'+match[0]+'.m3u8'
link2=main.OPENURL(durl)
match=re.compile('http://(.+?).m3u8').findall(link2)
for n in match: print n
if len(match)==0: xbmc.executebuiltin("XBMC.Notification(Sorry!,Link Cannot Be Played,5000)")
else:
if selfAddon.getSetting("vice-qua") == "0":
try: stream_url = 'http://'+match[4]+'.m3u8'
except: stream_url = 'http://'+match[3]+'.m3u8'
elif selfAddon.getSetting("vice-qua") == "1":
try: stream_url = 'http://'+match[1]+'.m3u8'
except: stream_url = 'http://'+match[3]+'.m3u8'
else: stream_url = durl
infoL={ "Title": mname, "Plot": desc}
# play with bookmark
from resources.universal import playbackengine, watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='', title=mname,season='', episode='', year='',img=thumb,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true": wh.add_item(mname+' '+'[COLOR green]Vice[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return ok
match2=re.compile('content="http://www.youtube.com/v/(.+?)" />').findall(link)
if len(match2)>0: url='http://www.youtube.com/watch?v='+match2[0]
listitem = xbmcgui.ListItem(mname)
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(str(url))
if(stream_url == False):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Link Cannot Be Resolved,5000)")
return
# play with bookmark
from resources.universal import playbackengine, watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='', title=mname,season='', episode='', year='',img=thumb,infolabels='', watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true": wh.add_item(mname+' '+'[COLOR green]Vice[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb2, fanart='', is_folder=False)
player.KeepAlive()
return ok
def LINKINT3(name,murl,thumb):
sources = []
main.GA("Cinevip","Watched")
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting Hosts,3000)")
link=main.OPENURL(murl)
link=link.replace('\r','').replace('\n','').replace('\t','').replace(' ','')
ok=True
infoLabels =main.GETMETAT(name,'','',thumb)
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
match=re.compile('class=".+?">([^<]+)</span></td><td>([^<]+)</td><td>([^<]+)</td>.+?adf.ly/.+?/(.+?)"').findall(link)
if len(match) == 0:
match=re.compile('<td><span class=".+?">.+?</span></td><td><span class=".+?">(.+?)</span></td><td>(.+?)</td><td>(.+?)</td>.+?<a .+?href=(.+?)>.+?</a>').findall(link)
for host, lang, qua, url in match:
print url
url=url.replace('target="_blank"','').replace('"','')
hosted_media = urlresolver.HostedMediaFile(url=url, title=host+' [COLOR red]'+lang+'[/COLOR] '+qua)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
listitem = xbmcgui.ListItem(thumbnailImage=thumb)
listitem.setInfo('video', {'Title': name, 'Year': ''} )
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=infoLabels['title'],season=season, episode=episode, year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(name+' '+'[COLOR green]Cinevip[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKSP3(mname,url):
main.GA("Dailyfix","Watched")
sources = []
ok=True
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting Hosts,8000)")
infoLabels =main.GETMETAT(mname,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
link=main.OPENURL(url)
match=re.compile("<a href='(.+?)' class='.+?' title='.+?' rel='.+?'>.+?</a").findall(link)
import urlresolver
main.CloseAllDialogs()
for murl in match:
host=re.compile("http://(.+?)\.[^/]+?/.+?").findall(murl)
for hname in host:
hname=hname.replace('www.','').title()
hosted_media = urlresolver.HostedMediaFile(url=murl, title="[COLOR blue]" + hname + "[/COLOR]")
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Movie doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
try:
if source:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Actual HD Movie Requires Buffer Time,7000)")
stream_url = main.resolve_url(source.get_url())
else:
stream_url = False
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory('plugin.video.movie25')
wh.add_item(mname+' '+'[COLOR green]DailyFix[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINK(mname,murl,thumb):
main.GA(mname,"Watched")
ok=True
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
stream_url = main.resolve_url(murl)
listitem = xbmcgui.ListItem(thumbnailImage=thumb)
listitem.setInfo('video', {'Title': mname, 'Genre': 'Custom'} )
playlist.add(stream_url,listitem)
xbmcPlayer = xbmc.Player()
xbmcPlayer.play(playlist)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Custom Channel[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
return ok
def VIDEOLINKS(mname,url):
ok=True
hname=mname
hname=hname.split(' online')[0]
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Opening Link,3000)")
r=re.findall('Season(.+?)Episode([^<]+)',mname)
if r:
mname=mname.split(' [COLOR blue]')[0]
infoLabels =main.GETMETAEpiT(mname,'','')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
else:
mname=mname.split(' [COLOR blue]')[0]
infoLabels =main.GETMETAT(mname,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
r=re.findall('xoxv(.+?)xoxe(.+?)xoxc',url)
import urlresolver
for hoster, url in r:
source = urlresolver.HostedMediaFile(host=hoster, media_id=url)
try :
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import playbackengine, watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(hname+' '+'[COLOR=FF67cc33]TubePlus[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=str(img), fanart=str(fanart), is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINKVD(name, murl, thumb):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
main.GA("Video Documentaire", "Watched")
stream_url = False
ok = True
link = main.OPENURL(murl)
try:
match = re.compile('''<iframe.+?src="(.+?)".+?</iframe>''',
re.DOTALL).findall(link)[0]
if 'http:' not in match:
match = 'http:' + match
stream_url = main.resolve_url(match.replace('?rel=0', ''))
except:
xbmc.executebuiltin(
"XBMC.Notification(Sorry!,Link Removed or Dead,3000)")
try:
listitem = xbmcgui.ListItem(thumbnailImage=thumb)
listitem.setInfo('video', {'Title': name, 'Year': ''})
infoL = {'Title': name, 'Plot': '', 'Genre': ''}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(
resolved_url=stream_url,
addon_id=addon_id,
video_type='',
title=name,
season='',
episode='',
year='',
img=thumb,
infolabels=infoL,
watchedCallbackwithParams=main.WatchedCallbackwithParams,
imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(name + ' ' + '[COLOR green]Video Documentaire[/COLOR]',
sys.argv[0] + sys.argv[2],
infolabels=infoL,
img=thumb,
fanart='',
is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def getvideo2(murl,answer=''):
link2=main.OPENURL(murl)
stream_url3= re.compile("f=(.+?)',").findall(link2)
if stream_url3:
link3=main.OPENURL(stream_url3[0])
stream_url4= re.compile("<hd>([^>]+?)</hd>").findall(link3)
if stream_url4:
return stream_url4[0]
else:
stream_url4= re.compile("<src>([^>]+?)</src>").findall(link3)
return stream_url4[0]
linkx=dekode(link2)
stream_url2= re.compile('file: "(.+?)"').findall(linkx)
if stream_url2:
return stream_url2[0]
else:
namelist=[]
urllist=[]
SRT=os.path.join(datapath,'Sub.srt')
link2=link2.replace('\r','').replace('\n','').replace('\t','').replace(' ','').replace('iframe src="//www.facebook.com','')
docUrl= re.compile('iframe src="(.+?preview)"').findall(link2)
if docUrl: docUrl=docUrl[0]
else:
link3=dekode(link2)
try:
docid= re.compile('docid=(.+?)\&').findall(link3)
if docid:
docUrl='https://docs.google.com/file/d/'+docid[0]+'/preview'
else:
docUrl= re.compile('iframe src="(.+?)"').findall(link3)[0]
except:
youtube= re.compile('<iframe width=".+?" height=".+?" src="http://www.youtube.com/embed/(.+?)" scrolling=".+?"').findall(link2)
url = "plugin://plugin.video.youtube/?path=/root/video&action=play_video&videoid="+youtube[0]+"&hd=1"
stream_url = url
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='', title=mname,season='', episode='', year='',img=thumb,infolabels='', watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]SominalFilms[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
player.KeepAlive()
return ok
if docUrl:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting Links,3000)")
stream_url = main.resolve_url(docUrl.replace('\/','/'))
return stream_url
def VIDEOLINKSEXTRA(mname,murl,thumb,desc):
main.GA("Watching Now","Watched")
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Collecting hosts,5000)")
sources = []
link=main.OPENURL(murl)
ok=True
infoLabels =main.GETMETAT(mname,'','',thumb)
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
match=re.compile('<strong><a href="(.+?)" target=".+?">(.+?)</a>',re.DOTALL).findall(link)
import urlresolver
for url, host in match:
link2=getlink(murl,url)
xurl=re.findall('var click_url = "(.+?)";',link2)[0]
hosted_media = urlresolver.HostedMediaFile(url=xurl, title=host)
sources.append(hosted_media)
if (len(sources)==0):
xbmc.executebuiltin("XBMC.Notification(Sorry!,Show doesn't have playable links,5000)")
else:
source = urlresolver.choose_source(sources)
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(mname+' '+'[COLOR green]Watching Now[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart='', is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def VIDEOLINKS(mname,url):
ok=True
hname=mname
hname=hname.split(' online')[0]
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Opening Link,3000)")
r=re.findall('Season(.+?)Episode([^<]+)',mname)
if r:
mname=mname.split(' [COLOR blue]')[0]
infoLabels =main.GETMETAEpiT(mname,'','')
video_type='episode'
season=infoLabels['season']
episode=infoLabels['episode']
else:
mname=mname.split(' [COLOR blue]')[0]
infoLabels =main.GETMETAT(mname,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
r=re.findall('xoxv(.+?)xoxe(.+?)xoxc',url)
import urlresolver
for hoster, url in r:
source = urlresolver.HostedMediaFile(host=hoster, media_id=url)
try :
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(source.get_url())
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
from resources.universal import playbackengine, watchhistory
wh = watchhistory.WatchHistory(addon_id)
wh.add_item(hname+' '+'[COLOR=FF67cc33]TubePlus[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=str(img), fanart=str(fanart), is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def getLink(links):
if 'byzoo' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)",',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'videobug' in links or 'easyvideo' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)",',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'yourupload' in links:
link=main.OPENURL(links)
try:
match=re.compile('<meta property="og.+?video" content="(.+?)"/>',re.DOTALL).findall(link)
if len(match)!=0:
match=urllib.unquote_plus(match[0])
except:pass
if 'video44' in links or 'video66' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)"',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'play44' in links or 'play66' in links or 'playbb' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)"',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'videoweed' in links:
try:stream_url = main.resolve_url(links)
except:pass
match=urllib.unquote_plus(stream_url)
if 'cheesestream' in links:
link=main.OPENURL(links)
try:match=re.compile('<meta property="og:video" content="(.+?)"/>',re.DOTALL).findall(link)[0]
except:pass
match=urllib.unquote_plus(match)
if 'videofun' in links:
link=main.OPENURL(links)
try:match=re.compile("""'fit'},.+?{url: "([^<]+)", autoPlay""",re.DOTALL).findall(link)[0]
except:pass
match=urllib.unquote_plus(match)
if 'yucache' in links:
link=main.OPENURL(links)
try:match=re.compile("""'<source src="([^"]+)" />';""",re.DOTALL).findall(link)[0]
except:pass
match=urllib.unquote_plus(match)
return match
def getLink(links):
if 'byzoo' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)",',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'videobug' in links or 'easyvideo' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)",',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'yourupload' in links:
link=main.OPENURL(links)
try:
match=re.compile('<meta property="og.+?video" content="(.+?)"/>',re.DOTALL).findall(link)
if len(match)!=0: match=urllib.unquote_plus(match[0])
except:pass
if 'video44' in links or 'video66' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)"',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'play44' in links or 'play66' in links or 'playbb' in links:
link=main.OPENURL(links)
try:match=re.compile("playlist:.+?url: '(.+?)',",re.DOTALL).findall(link)[0]
except:match=re.compile('file: "(.+?)"',re.DOTALL).findall(link)[0]
match=urllib.unquote_plus(match)
if 'videoweed' in links:
try:stream_url = main.resolve_url(links)
except:pass
match=urllib.unquote_plus(stream_url)
if 'cheesestream' in links:
link=main.OPENURL(links)
try:match=re.compile('<meta property="og:video" content="(.+?)"/>',re.DOTALL).findall(link)[0]
except:pass
match=urllib.unquote_plus(match)
if 'videofun' in links:
link=main.OPENURL(links)
try:match=re.compile("""'fit'},.+?{url: "([^<]+)", autoPlay""",re.DOTALL).findall(link)[0]
except:pass
match=urllib.unquote_plus(match)
if 'yucache' in links:
link=main.OPENURL(links)
try:match=re.compile("""'<source src="([^"]+)" />';""",re.DOTALL).findall(link)[0]
except:pass
match=urllib.unquote_plus(match)
return match
def resolveVID(murl):
murl=murl.split('"')[0]
murl=main.unescapes(murl)
link=main.OPENURL(murl)
match=re.compile('"http://www.youtube.com/v/([^<]+)"',re.DOTALL).findall(link)
if match:
vlink=main.resolve_url('http://www.youtube.com/v/'+match[0])
match2=re.compile('mediaId=([^<]+)&&defaultQuality',re.DOTALL).findall(link)
if match2:
link2=main.OPENURL('http://hadynz-shahid.appspot.com/scrape?m='+match2[0])
vlinks=re.compile('{"Quality":"(.+?)","URL":"(.+?)"}',re.DOTALL).findall(link2)
for qua,links in vlinks:
if '720' in qua:
vlink=links
else:
vlink=links
return vlink
def LINKVD(name, murl, thumb):
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = False
ok = True
link = main.OPENURL(murl)
try:
match = re.compile("""<iframe.+?src="(.+?)".+?</iframe>""", re.DOTALL).findall(link)[0]
if "http:" not in match:
match = "http:" + match
stream_url = main.resolve_url(match.replace("?rel=0", ""))
except:
xbmc.executebuiltin("XBMC.Notification(Sorry!,Link Removed or Dead,3000)")
try:
listitem = xbmcgui.ListItem(thumbnailImage=thumb)
listitem.setInfo("video", {"Title": name, "Year": ""})
infoL = {"Title": name, "Plot": "", "Genre": ""}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(
resolved_url=stream_url,
addon_id=addon_id,
video_type="",
title=name,
season="",
episode="",
year="",
img=thumb,
infolabels=infoL,
watchedCallbackwithParams=main.WatchedCallbackwithParams,
imdb_id="",
)
# WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(
name + " " + "[COLOR green]Video Documentaire[/COLOR]",
sys.argv[0] + sys.argv[2],
infolabels=infoL,
img=thumb,
fanart="",
is_folder=False,
)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def LINK(mname,murl,thumb):
main.GA(mname,"Watched")
ok=True
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
if '</regex>'in murl:
murl=main.doRegex(murl)
stream_url = main.resolve_url(murl)
listitem = xbmcgui.ListItem(thumbnailImage=thumb)
infoL={'Title': mname, 'Genre': 'Custom'}
from resources.universal import playbackengine
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type='movie', title=mname,season='', episode='', year='',img=thumb,infolabels=infoL, watchedCallbackwithParams='',imdb_id='')
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]Custom Channel[/COLOR]', sys.argv[0]+sys.argv[2], infolabels='', img=thumb, fanart='', is_folder=False)
return ok
def MLink(mname,suburl,thumb):
main.GA(mname,"Watched")
i=1
namelist=[]
urllist=[]
ok=True
infoLabels =main.GETMETAT(mname,'','','')
video_type='movie'
season=''
episode=''
img=infoLabels['cover_url']
fanart =infoLabels['backdrop_url']
imdb_id=infoLabels['imdb_id']
infolabels = { 'supports_meta' : 'true', 'video_type':video_type, 'name':str(infoLabels['title']), 'imdb_id':str(infoLabels['imdb_id']), 'season':str(season), 'episode':str(episode), 'year':str(infoLabels['year']) }
suburl=main.unescapes(suburl)
match=re.compile('<sublink>(.+?)</sublink><host>(.+?)</host>').findall(suburl)
for url,host in match:
namelist.append(host.upper())
urllist.append(url)
dialog = xbmcgui.Dialog()
answer =dialog.select("Pick Host", namelist)
if answer != -1:
murl=urllist[int(answer)]
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Opening Link,5000)")
else:
return
try:
xbmc.executebuiltin("XBMC.Notification(Please Wait!,Resolving Link,3000)")
stream_url = main.resolve_url(murl)
if(stream_url == False):
return
infoL={'Title': infoLabels['title'], 'Plot': infoLabels['plot'], 'Genre': infoLabels['genre']}
# play with bookmark
player = playbackengine.PlayWithoutQueueSupport(resolved_url=stream_url, addon_id=addon_id, video_type=video_type, title=str(infoLabels['title']),season=str(season), episode=str(episode), year=str(infoLabels['year']),img=img,infolabels=infoL, watchedCallbackwithParams=main.WatchedCallbackwithParams,imdb_id=imdb_id)
#WatchHistory
if selfAddon.getSetting("whistory") == "true":
wh.add_item(mname+' '+'[COLOR green]VIPlaylist[/COLOR]', sys.argv[0]+sys.argv[2], infolabels=infolabels, img=img, fanart=fanart, is_folder=False)
player.KeepAlive()
return ok
except Exception, e:
if stream_url != False:
main.ErrorReport(e)
return ok
def resolveVID(murl):
murl = murl.split('"')[0]
murl = main.unescapes(murl)
link = main.OPENURL(murl)
match = re.compile('"http://www.youtube.com/v/([^<]+)"',
re.DOTALL).findall(link)
if match:
vlink = main.resolve_url('http://www.youtube.com/v/' + match[0])
match2 = re.compile('mediaId=([^<]+)&&defaultQuality',
re.DOTALL).findall(link)
if match2:
link2 = main.OPENURL('http://hadynz-shahid.appspot.com/scrape?m=' +
match2[0])
vlinks = re.compile('{"Quality":"(.+?)","URL":"(.+?)"}',
re.DOTALL).findall(link2)
for qua, links in vlinks:
if '720' in qua:
vlink = links
else:
vlink = links
return vlink
