def get_servers(self, page_url, proxy_options=None):
T_BASE_URL = self.base_link
T_BASE_URL = 'https://%s' % client.geturlhost(page_url)
page_id = page_url.rsplit('.', 1)[1]
server_query = '/ajax/film/servers/%s' % page_id
server_url = urlparse.urljoin(T_BASE_URL, server_query)
log('INFO','get_servers', server_url, dolog=False)
result = proxies.request(server_url, headers=self.headers, referer=page_url, limit='0', proxy_options=proxy_options, use_web_proxy=self.proxyrequired, httpsskip=True)
html = '<html><body><div id="servers-container">%s</div></body></html>' % json.loads(result)['html'].replace('\n','').replace('\\','')
return html
def get_sources(self, url, hosthdDict=None, hostDict=None, locDict=None, proxy_options=None, key=None, testing=False):
try:
sources = []
if control.setting('Provider-%s' % name) == False:
log('INFO','get_sources','Provider Disabled by User')
log('INFO', 'get_sources', 'Completed')
return sources
if url == None:
log('FAIL','get_sources','url == None. Could not find a matching title: %s' % cleantitle.title_from_key(key), dolog=not testing)
log('INFO', 'get_sources', 'Completed')
return sources
links_m = []
data = self.flix.get_sources(url)
for d in data:
vidurl = d['url']
quality = d['quality']
poster = d['poster']
headers = {'Referer':url}
try:
if client.geturlhost(vidurl) not in self.avoidHosts:
l = resolvers.createMeta(vidurl, self.name, self.logo, quality, [], key, poster=poster, testing=testing, headers=headers)
for ll in l:
if ll != None and 'key' in ll.keys():
links_m.append(ll)
if testing == True:
break
except Exception as e:
log('ERROR', 'get_sources-0', '%s' % e, dolog=not testing)
for l in links_m:
if l != None and 'key' in l.keys():
sources.append(l)
if len(sources) == 0:
log('FAIL','get_sources','Could not find a matching title: %s' % cleantitle.title_from_key(key))
else:
log('SUCCESS', 'get_sources','%s sources : %s' % (cleantitle.title_from_key(key), len(sources)))
log('INFO', 'get_sources', 'Completed')
return sources
except Exception as e:
log('ERROR', 'get_sources', '%s' % e)
log('INFO', 'get_sources', 'Completed')
return sources
def createMeta(self, url, provider, logo, quality, links, key, riptype, vidtype='Movie', lang='en', sub_url=None, txt='', file_ext = '.mp4', testing=False, poster=None, headers=None, page_url=None):
files_ret = []
orig_url = url
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO','createMeta','Host Disabled by User')
return links
try:
items = self.process(url, quality, riptype, headers, page_url)
seq = 0
for item in items:
vidurl = item['src']
durl = url
allowsStreaming = item['allowsStreaming']
allowsDownload = item['allowsDownload']
quality = item['quality']
riptype = item['riptype']
fs = item['fs']
online = item['online']
params = item['params']
urldata = item['urldata']
try:
log(type='INFO',method='createMeta', err=u'durl:%s ; res:%s; fs:%s' % (durl,quality,fs))
files_ret.append({'source':self.name, 'maininfo':txt, 'titleinfo':'', 'quality':quality, 'vidtype':vidtype, 'rip':riptype, 'provider':provider, 'orig_url':orig_url, 'url':vidurl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':allowsStreaming, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':client.geturlhost(url), 'page_url':page_url, 'misc':{'player':'eplayer', 'gp':True}, 'seq':seq})
except Exception as e:
log(type='ERROR',method='createMeta', err=u'%s' % e)
files_ret.append({'source':urlhost, 'maininfo':txt, 'titleinfo':'', 'quality':quality, 'vidtype':vidtype, 'rip':'Unknown' ,'provider':provider, 'orig_url':orig_url, 'url':vidurl, 'durl':url, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':allowsStreaming, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':client.geturlhost(url), 'page_url':page_url, 'misc':{'player':'eplayer', 'gp':True}, 'seq':seq})
seq += 1
except Exception as e:
log(type='ERROR', err="createMeta : %s" % e.args)
for fr in files_ret:
if fr != None and 'key' in fr.keys():
control.setPartialSource(fr,self.name)
links.append(fr)
if len(files_ret) > 0:
log('SUCCESS', 'createMeta', 'Successfully processed %s link >>> %s' % (provider, orig_url), dolog=self.init)
else:
log('FAIL', 'createMeta', 'Failed in processing %s link >>> %s' % (provider, orig_url), dolog=self.init)
log('INFO', 'createMeta', 'Completed', dolog=self.init)
return links
def get_sources(self,
url,
hosthdDict=None,
hostDict=None,
locDict=None,
proxy_options=None,
key=None,
testing=False):
try:
sources = []
if control.setting('Provider-%s' % name) == False:
log('INFO', 'get_sources', 'Provider Disabled by User')
return sources
if url == None:
log('FAIL',
'get_sources',
'url == None. Could not find a matching title: %s' %
cleantitle.title_from_key(key),
dolog=not testing)
return sources
links_m = []
TYPES_QUAL = {
'SD': '480p',
'3D SD': '480p',
'HD': '1080p',
'3D FullHD': '1080p'
}
#TYPES_RIP = {'SD':'BRRIP', '3D SD':'3D-BRRIP', 'HD':'3D-BRRIP', '3D FullHD':'3D-BRRIP'}
for data_j in url:
try:
file = data_j['file']
src_file = data_j['src_file']
page = data_j['page']
label = data_j['label']
sub_url = data_j['srt']
poster = data_j['poster']
qual = '480p'
riptype = '3D-BRRIP'
data_j['file'] = urlparse.urljoin(self.base_link, file)
if label in TYPES_QUAL.keys():
qual = TYPES_QUAL[label]
data_j['label'] = qual
file_data = urllib.urlencode(data_j)
links_m = resolvers.createMeta(file_data,
self.name,
self.logo,
qual,
links_m,
key,
riptype,
testing=testing,
sub_url=sub_url,
urlhost=client.geturlhost(
self.base_link),
poster=poster)
if testing == True and len(links_m) > 0:
break
except:
pass
for l in links_m:
sources.append(l)
if len(sources) == 0:
log(
'FAIL', 'get_sources',
'Could not find a matching title: %s' %
cleantitle.title_from_key(key))
return sources
log('SUCCESS',
'get_sources',
'%s sources : %s' %
(cleantitle.title_from_key(key), len(sources)),
dolog=not testing)
return sources
except Exception as e:
log('ERROR', 'get_sources', '%s' % e, dolog=not testing)
return sources
def get_sources(self, page_url):
try:
sources = []
html = client.request(page_url)
action = 'getEpisodeEmb' if '/episode/' in page_url else 'getMovieEmb'
match = re.search('elid\s*=\s*"([^"]+)', html)
if self.__token is None:
self.__get_token()
if match and self.__token is not None:
elid = urllib.quote(
base64.encodestring(str(int(time.time()))).strip())
data = {
'action': action,
'idEl': match.group(1),
'token': self.__token,
'elid': elid,
'nopop': ''
}
ajax_url = urlparse.urljoin(self.base_url, SOURCES_URL)
headers = {
'authorization':
'Bearer %s' % (self.__get_bearer()),
'Referer':
page_url,
'User-Agent':
'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36'
}
#headers.update(XHR)
try:
poster = client.parseDOM(html,
'div',
attrs={'class': 'poster'})[0]
poster = client.parseDOM(poster, 'img', ret='data-src')[0]
except:
poster = None
data = client.encodePostData(data)
html = client.request(ajax_url,
post=data,
cookie=self.cookie,
headers=headers)
html = html.replace('\\"', '"').replace('\\/', '/')
rep_txt = re.findall(r'<iframe(.*?)</iframe>', html,
re.IGNORECASE)
for rep in rep_txt:
html = html.replace(rep, rep.replace('"', '\''))
if html == None or len(html) == 0:
raise Exception('HTML data not found on %s' % ajax_url)
json_html = json.loads(html)
for k in json_html.keys():
html = json_html[k]['embed']
quality, t = cleantitle.getQuality2(
json_html[k]['type'].replace('fbcdn',
'').replace('-',
'').strip())
pattern = '<iframe\s+src=\'([^\']+)'
for match in re.finditer(pattern, html, re.DOTALL | re.I):
url = match.group(1)
host = client.geturlhost(url)
direct = True
if host == 'gvideo':
direct = True
quality = client.googletag(url)
else:
if 'vk.com' in url and url.endswith('oid='):
continue # skip bad vk.com links
direct = False
host = urlparse.urlparse(url).hostname
source = {
'multi-part': False,
'url': url,
'host': host,
'quality': quality,
'views': None,
'rating': None,
'direct': direct,
'poster': poster
}
sources.append(source)
except:
pass
return sources
def createMeta(self,
url,
provider,
logo,
quality,
links,
key,
riptype,
showsplit=False,
useGetlinkAPI=True,
vidtype='Movie',
lang='en',
sub_url=None,
txt='',
file_ext='.mp4',
testing=False):
orig_url = url
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO', 'createMeta', 'Host Disabled by User')
return links
if 'http' not in url and 'google.com/file' in url:
url = 'https://drive.google.com/' + url.split('.com/')[1]
httpsskip = False
if control.setting('use_https_alt') != None and (
control.setting('use_https_alt') == True
or control.setting('use_https_alt') == False):
httpsskip = control.setting('httpsskip')
#print "createMeta1 : %s %s %s %s" % (url, provider, logo, quality)
videoData, headers, content, cookie = getVideoMetaData(url, httpsskip)
try:
cookie += '; %s' % content['Set-Cookie']
# cookie_s = cookie.split(';')
# cookie_n = []
# for cook in cookie_s:
# cook = cook.strip()
# if '=' in cook and cook not in cookie_n:
# cookie_n.append(cook)
# cookie = ('; '.join(x for x in sorted(cookie_n)))
cookie_value = client.search_regex(r"DRIVE_STREAM=([^;]+);",
cookie,
'cookie val',
group=1)
domain = client.search_regex(r"https?://([^\/]+)",
url,
'host val',
group=1)
cookie = 'DRIVE_STREAM=%s; path=/; domain=.%s;' % (cookie_value,
domain)
except:
pass
#print cookie
#cookie = urllib.quote_plus(cookie).replace('+','%20').replace('%2F','/')
# DRIVE_STREAM%3Dva1wsBbVn3A%3B%20path%3D/%3B%20domain%3D.docs.google.com%3B
# DRIVE_STREAM%3DtV76KFL8a6k%3B+path%3D%2F%3B+domain%3D.docs.google.com%3B
params = {'headers': headers, 'cookie': cookie}
params = json.dumps(params, encoding='utf-8')
params = client.b64encode(params)
if client.geturlhost(url) in self.host[4]:
pass # skip for googleapis.com link
else:
quality = file_quality(url, quality, videoData)[0]
isOnline = check(url,
videoData,
headers=headers,
cookie=cookie,
httpsskip=httpsskip)[0]
type = rip_type(url, riptype)
files = []
#print "createMeta : %s %s %s %s" % (url, provider, logo, quality)
titleinfo = txt
if txt != '':
titleinfo = txt
ntitleinfo = titleinfo
files_ret = []
enabled = True
try:
#udata = urldata(url, videoData=videoData, usevideoData=True)
if 'google.com/file' in url:
idstr = '%s' % (url.split('/preview')[0].split('/edit')
[0].split('/view')[0])
idstr = idstr.split('/')
id = idstr[len(idstr) - 1]
try:
durl, f_res, fs = getFileLink(id, httpsskip)
except:
fs = 0
durl = None
if durl != None:
files_ret.append({
'source': self.name,
'maininfo': '',
'titleinfo': ntitleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': type,
'provider': provider,
'url': durl,
'durl': durl,
'urldata': createurldata(durl, quality),
'params': params,
'logo': logo,
'online': isOnline,
'allowsDownload': self.allowsDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': enabled,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(durl),
'misc': {
'player': 'iplayer',
'gp': False
}
})
else:
fs = client.getFileSize(url, retry429=True)
files_ret.append({
'source': self.name,
'maininfo': '',
'titleinfo': ntitleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': type,
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata('', ''),
'params': params,
'logo': logo,
'online': isOnline,
'allowsDownload': self.allowsDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': enabled,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'eplayer',
'gp': False
}
})
else:
fs = client.getFileSize(url, retry429=True)
files_ret.append({
'source': self.name,
'maininfo': '',
'titleinfo': ntitleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': type,
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata('', ''),
'params': params,
'logo': logo,
'online': isOnline,
'allowsDownload': self.allowsDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': enabled,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'iplayer',
'gp': False
}
})
except Exception as e:
log(type='ERROR', method='createMeta-1', err=u'%s' % e)
isGetlinkWork = False
try:
if useGetlinkAPI == True and isOnline and 'google.com/file' in url and self.useGetLinkAPI:
client.setIP4()
ntitleinfo = titleinfo + ' | (via GetLink API) '
files = urldata(url)
files = client.b64decode(files)
filesJ = json.loads(files)
if len(filesJ) > 0:
for mfile in filesJ:
mfile = json.loads(mfile)
#print "mfile --- : %s" % mfile
furl = mfile['src']
f2url = client.request(furl,
followredirect=True,
output='geturl')
if 'http' in f2url:
furl = f2url
#print "furl --- : %s" % furl
quality = file_quality(furl, mfile['res'],
videoData)[0]
isOnlineT = check(furl,
videoData,
headers=headers,
cookie=cookie)[0]
type = rip_type(furl, riptype)
else:
isOnlineT = 'Unknown'
p = {'headers': '', 'cookie': ''}
p = json.dumps(p, encoding='utf-8')
p = client.b64encode(p)
fs = client.getFileSize(furl, retry429=True)
files_ret.append({
'source': self.name,
'maininfo': '',
'titleinfo': ntitleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': type,
'provider': provider,
'url': furl,
'durl': furl,
'urldata': urldata('', ''),
'params': p,
'logo': logo,
'online': isOnlineT,
'allowsDownload': self.allowsDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': enabled,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(furl),
'misc': {
'player': 'iplayer',
'gp': False
}
})
isGetlinkWork = True
client.setIP6()
except Exception as e:
log(type='ERROR', method='createMeta-2', err=u'%s' % e)
try:
if showsplit == True and isOnline and isGetlinkWork == False:
# currently suffers from transcoding failure on most clients
ntitleinfo = titleinfo + ' | *limited support* '
files = get_files(url, videoData)[0]
for furl in files:
quality = file_quality(furl, quality, videoData)[0]
type = rip_type(furl, riptype)
furl = urllib.unquote(furl).decode('utf8')
furl = furl.decode('unicode_escape')
isOnlineT = check(furl,
videoData,
headers=headers,
cookie=cookie)[0]
fs = client.getFileSize(furl, retry429=True)
files_ret.append({
'source': self.name,
'maininfo': '',
'titleinfo': ntitleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': type,
'provider': provider,
'url': furl,
'durl': furl,
'urldata': createurldata(furl, quality),
'params': params,
'logo': logo,
'online': isOnlineT,
'allowsDownload': self.allowsDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': enabled,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(furl),
'misc': {
'player': 'iplayer',
'gp': False
}
})
except Exception as e:
log(type='ERROR', method='createMeta-3', err=u'%s' % e)
for fr in files_ret:
fr['resumeDownload'] = self.resumeDownload
links.append(fr)
log('INFO',
'createMeta',
'Successfully processed %s link >>> %s' % (provider, orig_url),
dolog=self.init)
return links
def createMeta(self, url, provider, logo, quality, links, key, riptype, vidtype='Movie', lang='en', sub_url=None, txt='', file_ext = '.mp4', testing=False, poster=None, headers=None):
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO','createMeta','Host Disabled by User')
return links
orig_url = url
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
online = check(url)
vidurls, err, sub_url_t = getAllQuals(url, online)
if vidurls == None:
log(type='ERROR',method='createMeta-1', err=u'%s' % err)
return links
if sub_url_t != None:
sub_url = sub_url_t
files_ret = []
for vv in vidurls:
durl = vv['page']
vidurl, r1, r2 = resolve(durl, online)
if vidurl != None:
quality = vv['label']
try:
#vidurl_t = client.request(vidurl, output='geturl')
fs = client.getFileSize(vidurl)
fs = int(fs)
except Exception as e:
log(type='ERROR',method='createMeta', err=u'%s' % e)
fs = 0
try:
log(type='INFO',method='createMeta', err=u'durl:%s ; res:%s; fs:%s' % (vidurl,quality,fs))
files_ret.append({'source':self.name, 'maininfo':'', 'titleinfo':txt, 'quality':quality, 'vidtype':vidtype, 'rip':riptype, 'provider':provider, 'url':durl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'key':key, 'enabled':True, 'fs':fs, 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'poster':poster, 'sub_url':sub_url, 'subdomain':client.geturlhost(url), 'misc':{'player':'iplayer', 'gp':False}})
except Exception as e:
log(type='ERROR',method='createMeta', err=u'%s' % e)
files_ret.append({'source':urlhost, 'maininfo':'', 'titleinfo':txt, 'quality':quality, 'vidtype':vidtype, 'rip':'Unknown' ,'provider':provider, 'url':durl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'key':key, 'enabled':True, 'fs':fs, 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':client.geturlhost(url), 'misc':{'player':'iplayer', 'gp':False}})
for fr in files_ret:
links.append(fr)
log('INFO', 'createMeta', 'Successfully processed %s link >>> %s' % (provider, orig_url), dolog=self.init)
return links
def createMeta(self, url, provider, logo, quality, links, key, riptype, vidtype='Movie', lang='en', sub_url=None, txt='', file_ext = '.mp4', testing=False, poster=None, headers=None, page_url=None):
files_ret = []
url = url.replace('oload.tv','openload.co').replace('/embed/','/f/')
orig_url = url
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO','createMeta','Host Disabled by User')
return links
try:
durl = url
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
a1 = None
if control.setting('use_openload_pairing') == True:
isPairRequired, a1 = isPairingRequired(url)
if isPairRequired == True:
isPairRequired, a1 = isPairingRequired(url)
#print "isPairRequired %s" % isPairRequired
else:
isPairRequired = False
page_html = client.request(url)
if a1 != None:
vidurl = a1
else:
vidurl, err, sub_url_t, r1 = resolve(url, usePairing=False)
if sub_url == None:
sub_url = sub_url_t
if vidurl != None:
isPairRequired = False
pair = ''
if isPairRequired == True:
pair = ' *Pairing required* '
if isPairingDone():
pair = ' *Paired* '
if vidurl == None:
vidurl = url
online, r1, r2, fs, r3, sub_url_t = check(vidurl, videoData=page_html, usePairing=False, embedpage=True)
if online == False:
pair = ' *Vid Unavailable* '
file_title = ''
try:
file_title = client.parseDOM(page_html, 'title')[0]
except:
try:
file_title = client.parseDOM(page_html, 'span', attrs = {'class': 'title'})[0]
except:
try:
file_title = client.parseDOM(page_html, 'h3', attrs = {'class': 'other-title-bold'})[0]
except:
pass
if sub_url == None:
sub_url = sub_url_t
titleinfo = txt
try:
log(type='INFO',method='createMeta', err=u'pair:%s; online:%s; durl:%s ; res:%s; fs:%s' % (isPairRequired,online,vidurl,quality,fs))
files_ret.append({'source':self.name, 'maininfo':pair, 'titleinfo':titleinfo, 'quality':file_quality(vidurl, quality, file_title), 'vidtype':vidtype, 'rip':rip_type(vidurl, riptype, file_title), 'provider':provider, 'orig_url':orig_url, 'url':vidurl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':client.geturlhost(url), 'page_url':page_url, 'misc':{'pair':isPairRequired, 'player':'iplayer', 'gp':False}, 'seq':0})
except Exception as e:
log(type='ERROR',method='createMeta-3', err=u'%s' % e)
files_ret.append({'source':urlhost, 'maininfo':pair, 'titleinfo':titleinfo, 'quality':quality, 'vidtype':vidtype, 'rip':'Unknown' ,'provider':provider, 'orig_url':orig_url, 'url':vidurl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':client.geturlhost(url), 'page_url':page_url, 'misc':{'pair':isPairRequired, 'player':'eplayer', 'gp':False}, 'seq':0})
except Exception as e:
log('ERROR', 'createMeta', '%s' % e)
for fr in files_ret:
if fr != None and 'key' in fr.keys():
control.setPartialSource(fr,self.name)
links.append(fr)
if len(files_ret) > 0:
log('SUCCESS', 'createMeta', 'Successfully processed %s link >>> %s' % (provider, orig_url), dolog=self.init)
else:
log('FAIL', 'createMeta', 'Failed in processing %s link >>> %s' % (provider, orig_url), dolog=self.init)
log('INFO', 'createMeta', 'Completed', dolog=self.init)
return links
def createMeta(self,
url,
provider,
logo,
quality,
links,
key,
riptype,
vidtype='Movie',
lang='en',
sub_url=None,
txt='',
file_ext='.mp4',
testing=False):
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO', 'createMeta', 'Host Disabled by User')
return links
url = url.replace('oload.tv', 'openload.co').replace('/embed/', '/f/')
orig_url = url
durl = url
if testing == False:
log(type='INFO',
method='createMeta-1',
err=u'creating meta for url: %s' % url)
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
a1 = None
if control.setting('use_openload_pairing') == True:
isPairRequired, a1 = isPairingRequired(url)
if isPairRequired == True:
isPairRequired, a1 = isPairingRequired(url)
#print "isPairRequired %s" % isPairRequired
else:
isPairRequired = False
if a1 != None:
vidurl = a1
else:
vidurl, err, sub_url_t = resolve(url, usePairing=False)
if sub_url == None:
sub_url = sub_url_t
if vidurl != None:
isPairRequired = False
pair = ''
if isPairRequired == True:
pair = ' *Pairing required* '
if isPairingDone():
pair = ' *Paired* '
if vidurl == None:
vidurl = url
online, r1, r2, fs, r3, sub_url_t = check(vidurl,
usePairing=False,
embedpage=True)
if sub_url == None:
sub_url = sub_url_t
files_ret = []
titleinfo = txt
if testing == False:
log(type='INFO',
method='createMeta-2',
err=u'pair: %s online: %s resolved url: %s' %
(isPairRequired, online, vidurl))
try:
files_ret.append({
'source': self.name,
'maininfo': pair,
'titleinfo': titleinfo,
'quality': file_quality(vidurl, quality),
'vidtype': vidtype,
'rip': rip_type(vidurl, riptype),
'provider': provider,
'url': vidurl,
'durl': durl,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'pair': isPairRequired,
'player': 'iplayer',
'gp': False
}
})
except Exception as e:
log(type='ERROR', method='createMeta-3', err=u'%s' % e)
files_ret.append({
'source': urlhost,
'maininfo': pair,
'titleinfo': titleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': 'Unknown',
'provider': provider,
'url': vidurl,
'durl': durl,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'pair': isPairRequired,
'player': 'eplayer',
'gp': False
}
})
for fr in files_ret:
links.append(fr)
log('INFO',
'createMeta',
'Successfully processed %s link >>> %s' % (provider, orig_url),
dolog=self.init)
return links
def createMeta(self,
url,
provider,
logo,
quality,
links,
key,
riptype,
vidtype='Movie',
lang='en',
sub_url=None,
txt='',
file_ext='.mp4',
testing=False,
poster=None,
headers=None):
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO', 'createMeta', 'Host Disabled by User')
return links
orig_url = url
files_ret = []
items = self.process(url, quality, riptype, headers)
for item in items:
url = item['src']
quality = item['quality']
riptype = item['riptype']
fs = item['fs']
online = item['online']
params = item['params']
urldata = item['urldata']
try:
files_ret.append({
'source': self.name,
'maininfo': txt,
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': riptype,
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'poster': poster,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'eplayer',
'gp': True
}
})
except Exception as e:
log(type='ERROR', method='createMeta', err=u'%s' % e)
files_ret.append({
'source': urlhost,
'maininfo': txt,
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': 'Unknown',
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'poster': poster,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'eplayer',
'gp': True
}
})
for fr in files_ret:
links.append(fr)
log('INFO',
'createMeta',
'Successfully processed %s link >>> %s' % (provider, orig_url),
dolog=self.init)
return links
def createMeta(self, url, provider, logo, quality, links, key, riptype, vidtype='Movie', lang='en', sub_url=None, txt='', file_ext = '.mp4', testing=False, poster=None, headers=None, page_url=None):
files_ret = []
orig_url = url
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO','createMeta','Host Disabled by User')
return links
try:
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
online = check(url)
vidurls, err, sub_url_t = getAllQuals(url, online)
if vidurls == None:
log(type='ERROR',method='createMeta-1', err=u'%s' % err)
return links
if sub_url_t != None:
sub_url = sub_url_t
seq = 0
for vv in vidurls:
durl = vv['page']
vidurl = vv['file']
if vidurl != None:
quality = vv['label']
fs = vv['fs']
try:
log(type='INFO',method='createMeta', err=u'durl:%s ; res:%s; fs:%s' % (durl,quality,fs))
files_ret.append({'source':self.name, 'maininfo':'', 'titleinfo':txt, 'quality':quality, 'vidtype':vidtype, 'rip':riptype, 'provider':provider, 'orig_url':orig_url, 'url':vidurl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'poster':poster, 'sub_url':sub_url, 'subdomain':client.geturlhost(url), 'page_url':page_url, 'misc':{'player':'iplayer', 'gp':False}, 'seq':seq})
except Exception as e:
log(type='ERROR',method='createMeta', err=u'%s' % e)
files_ret.append({'source':urlhost, 'maininfo':'', 'titleinfo':txt, 'quality':quality, 'vidtype':vidtype, 'rip':'Unknown' ,'provider':provider, 'orig_url':orig_url, 'url':vidurl, 'durl':durl, 'urldata':urldata, 'params':params, 'logo':logo, 'online':online, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':client.geturlhost(url), 'page_url':page_url, 'misc':{'player':'iplayer', 'gp':False}, 'seq':seq})
seq += 1
except Exception as e:
log('ERROR', 'createMeta', '%s' % e)
for fr in files_ret:
if fr != None and 'key' in fr.keys():
control.setPartialSource(fr,self.name)
links.append(fr)
if len(files_ret) > 0:
log('SUCCESS', 'createMeta', 'Successfully processed %s link >>> %s' % (provider, orig_url), dolog=self.init)
else:
log('FAIL', 'createMeta', 'Failed in processing %s link >>> %s' % (provider, orig_url), dolog=self.init)
log('INFO', 'createMeta', 'Completed', dolog=self.init)
return links
def createMeta(self,
url,
provider,
logo,
quality,
links,
key,
riptype,
vidtype='Movie',
lang='en',
sub_url=None,
txt='',
file_ext='.mp4',
testing=False,
poster=None,
headers=None,
page_url=None):
files_ret = []
orig_url = url
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO', 'createMeta', 'Host Disabled by User')
return links
try:
if 'vidcloud.icu/load' in url:
raise Exception('No mp4 Video found')
elif 'vidcloud.icu/download' in url:
headersx = {'Referer': url, 'User-Agent': client.agent()}
page_data, head, ret, cookie = client.request(
url, output='extended', headers=headersx)
try:
cookie = re.findall(r'Set-Cookie:(.*)', str(ret),
re.MULTILINE)[0].strip()
except:
pass
headersx['Cookie'] = cookie
mp4_vids = re.findall(r'\"(http.*?.mp4.*?)\"', page_data)
items = []
for u in mp4_vids:
u = u.strip().replace(' ', '%20').replace('&', '&')
fs = client.getFileSize(u, headers=headersx)
q = qual_based_on_fs(quality, fs)
online = check(u, headers=headersx)
urldata = client.b64encode(json.dumps('',
encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
if headersx != None:
paramsx = {'headers': headers}
params = client.b64encode(
json.dumps(paramsx, encoding='utf-8'))
items.append({
'quality': q,
'riptype': riptype,
'src': u,
'fs': fs,
'online': online,
'params': params,
'urldata': urldata,
'allowsStreaming': False
})
seq = 0
for item in items:
durl = url
vidurl = item['src']
allowsStreaming = item['allowsStreaming']
quality = item['quality']
riptype = item['riptype']
fs = item['fs']
online = item['online']
params = item['params']
urldata = item['urldata']
try:
log(type='INFO',
method='createMeta',
err=u'durl:%s ; res:%s; fs:%s' %
(durl, quality, fs))
files_ret.append({
'source': self.name,
'maininfo': txt,
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': riptype,
'provider': provider,
'orig_url': orig_url,
'url': vidurl,
'durl': durl,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'poster': poster,
'subdomain': client.geturlhost(url),
'page_url': page_url,
'misc': {
'player': 'iplayer',
'gp': True
},
'seq': seq
})
except Exception as e:
log(type='ERROR', method='createMeta', err=u'%s' % e)
files_ret.append({
'source': urlhost,
'maininfo': txt,
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': 'Unknown',
'provider': provider,
'orig_url': orig_url,
'url': vidurl,
'durl': durl,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'poster': poster,
'subdomain': client.geturlhost(url),
'page_url': page_url,
'misc': {
'player': 'iplayer',
'gp': True
},
'seq': seq
})
seq += 1
elif url != None:
online = True
result = client.request(orig_url, httpsskip=True)
if 'Sorry, this video reuploading' in result:
online = False
if online == True:
vids = client.parseDOM(
result, 'ul', attrs={'class': 'list-server-items'})[0]
vids = client.parseDOM(vids,
'li',
attrs={'class': 'linkserver'},
ret='data-video')
vids = list(set(vids))
for video_url in vids:
video_urlx = video_url
if 'http' not in video_urlx:
video_urlx = 'http:' + video_urlx
if video_urlx != None and 'vidcloud.icu/load' not in video_urlx:
log(type='INFO',
method='createMeta',
err=u'url:%s requires additional processing' %
video_urlx)
video_url1 = '%s' % client.request(
video_urlx,
followredirect=True,
httpsskip=True,
output='geturl')
if video_url1 != None and 'http' in video_url1 and 'vidcloud.icu' not in video_url1:
try:
files_ret = resolvers.createMeta(
video_url1,
provider,
logo,
quality,
files_ret,
key,
poster=poster,
riptype=riptype,
vidtype=vidtype,
sub_url=sub_url,
testing=testing,
headers=headers,
page_url=page_url)
except Exception as e:
log(type='ERROR',
method='createMeta',
err=u'%s' % e)
elif video_urlx != None and 'vidcloud.icu/load' in video_urlx:
log(type='INFO',
method='createMeta',
err=u'url:%s requires additional processing' %
video_urlx)
id = re.findall(r'id=(.*?)&', video_urlx)[0]
u = 'https://vidcloud.icu/download?id=%s' % id
res = client.request(u)
mp4_vids = re.findall(r'http.*?mp4', res)
if len(mp4_vids) > 0:
try:
files_ret = resolvers.createMeta(
u,
provider,
logo,
quality,
files_ret,
key,
poster=poster,
riptype=riptype,
vidtype=vidtype,
sub_url=sub_url,
testing=testing,
headers=headers,
page_url=page_url,
urlhost='vidcloud.icu')
except Exception as e:
log(type='ERROR',
method='createMeta',
err=u'%s' % e)
elif len(mp4_vids) == 0 and video_url == vids[
len(vids) - 1] and len(files_ret) == 0:
raise Exception('No mp4 Video found')
except Exception as e:
log('FAIL', 'createMeta', '%s' % e)
for fr in files_ret:
if fr != None and 'key' in fr.keys():
control.setPartialSource(fr, self.name)
links.append(fr)
if len(files_ret) > 0:
log('SUCCESS',
'createMeta',
'Successfully processed %s link >>> %s' % (provider, orig_url),
dolog=self.init)
else:
log('FAIL',
'createMeta',
'Failed in processing %s link >>> %s' % (provider, orig_url),
dolog=self.init)
log('INFO', 'createMeta', 'Completed', dolog=self.init)
return links
def createMeta(url,
provider,
logo,
quality,
links,
key,
riptype=None,
vidtype='Movie',
lang='en',
sub_url=None,
txt='',
file_ext='.mp4',
testing=False):
if url == None or url == '':
return links
url = url.strip()
for item in links:
if url == item['durl']:
log("%s has already been processed" % url)
return links
quality = fixquality(quality)
links_m = []
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
try:
try:
urlhost = re.findall('([\w]+[.][\w]+)$',
urlparse.urlparse(
url.strip().lower()).netloc)[0]
except:
urlhost = re.findall('([\w]+[.][\w]+).*$',
urlparse.urlparse(
url.strip().lower()).netloc)[0]
urlhost = urlhost.split('.')[1]
if riptype == None:
riptype_def = 'BRRIP'
else:
riptype_def = riptype
for host in sourceHostsCall:
log("Searching %s in %s" % (urlhost, host['host']),
logToControl=False)
if urlhost in host['host']:
log("Found %s in %s" % (urlhost, host['host']))
return host['call'].createMeta(url,
provider,
logo,
quality,
links,
key,
riptype_def,
vidtype=vidtype,
lang=lang,
sub_url=sub_url,
txt=txt,
file_ext=file_ext,
testing=testing)
log("urlhost '%s' not found in host/resolver plugins - creating generic meta for external services"
% urlhost)
quality = file_quality(url, quality)
if riptype == None:
type = rip_type(url, quality)
else:
type = riptype
links_m.append({
'source': urlhost,
'maininfo': '',
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': type,
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata,
'params': params,
'logo': logo,
'online': 'Unknown',
'allowsDownload': False,
'resumeDownload': False,
'allowsStreaming': True,
'key': key,
'enabled': True,
'fs': int(0),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'eplayer',
'gp': False
}
})
except Exception as e:
log(type='ERROR', err="createMeta : %s url: %s" % (e.args, url))
links += [l for l in links_m]
return links
def createMeta(self,
url,
provider,
logo,
quality,
links,
key,
riptype,
vidtype='Movie',
lang='en',
sub_url=None,
txt='',
file_ext='.mp4',
testing=False):
if testing == True:
links.append(url)
return links
if control.setting('Host-%s' % name) == False:
log('INFO', 'createMeta', 'Host Disabled by User')
return links
orig_url = url
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
online = check(url)
files_ret = []
fs = client.getFileSize(url, retry429=True)
try:
files_ret.append({
'source': self.name,
'maininfo': txt,
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': riptype,
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'eplayer',
'gp': False
}
})
except Exception as e:
log(type='ERROR', method='createMeta', err=u'%s' % e)
files_ret.append({
'source': urlhost,
'maininfo': txt,
'titleinfo': '',
'quality': quality,
'vidtype': vidtype,
'rip': 'Unknown',
'provider': provider,
'url': url,
'durl': url,
'urldata': urldata,
'params': params,
'logo': logo,
'online': online,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'subdomain': client.geturlhost(url),
'misc': {
'player': 'eplayer',
'gp': False
}
})
for fr in files_ret:
links.append(fr)
log('INFO',
'createMeta',
'Successfully processed %s link >>> %s' % (provider, orig_url),
dolog=self.init)
return links
