def getAllQuals(url, online=None):
try:
if online == None:
if check(url) == False:
raise Exception('Video not available')
page_data_string = client.request(url, httpsskip=True)
video_urls, err = decode(page_data_string)
if video_urls == None:
raise Exception(err)
video_url_a = []
myheaders = {}
myheaders['User-Agent'] = client.agent()
myheaders['Referer'] = url
for v in video_urls:
try:
fs = client.getFileSize(v, retry429=True)
qs = qual_based_on_fs(fs)
f_i = {'label': '%s' % qs, 'file':v, 'fs':fs, 'page':url}
video_url_a.append(f_i)
except:
pass
video_urlf = video_url_a
return (video_urlf, '', None)
except Exception as e:
e = '{}'.format(e)
return (None, e, None)
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 sub_url_t != None:
sub_url = sub_url_t
seq = 0
for vv in vidurls:
durl = vv['page']
vidurl, r1, r2 = resolve(durl, online)
if vidurl != None and '.mp4' in vidurl:
quality = vv['label']
try:
fs = client.getFileSize(vidurl)
fs = int(fs)
except:
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, 'orig_url':orig_url, '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), 'page_url':page_url, 'misc':{'player':'iplayer', 'gp':False}, 'seq':seq})
except Exception as e:
log(type='FAIL',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':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), '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 decode(url, page_url):
items = []
err = ''
try:
id = re.compile('//.+?/(?:embed|v)/([0-9a-zA-Z-_]+)').findall(url)[0]
headersx = {
'Referer': 'https://www.xstreamcdn.com/v/%s' % id,
'User-Agent': client.agent()
}
post_data = {'r': page_url, 'd': 'www.xstreamcdn.com'}
api_url = 'https://www.xstreamcdn.com/api/source/%s' % id
page_data = client.request(api_url,
post=client.encodePostData(post_data),
headers=headersx)
j_data = json.loads(page_data)
success = j_data['success']
if success == False:
try:
msd = j_data['data']
except:
msd = ""
raise Exception(
'API returned error: %s | Data: %s | Return msg: %s' %
(api_url, post_data, msd))
else:
srcs = j_data['data']
for src in srcs:
q = src['label']
u = src['file']
fs = client.getFileSize(u, retry429=True, headers=headersx)
online = check(u)
u1 = client.request(u, output='geturl')
if u1 != None:
u = u1
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
paramsx = {'headers': headersx}
params = client.b64encode(json.dumps(paramsx,
encoding='utf-8'))
items.append({
'quality': q,
'src': u,
'fs': fs,
'online': online,
'params': params,
'urldata': urldata
})
if len(items) == 0:
raise Exception('No videos found !')
except Exception as e:
err = 'xtreamcdn Error: %s' % e
return items, err
def process(self, url, q, r, headers, page_url):
items = []
try:
if 'vcstream.to' in url:
id = re.compile('//.+?/(?:embed|f)/([0-9a-zA-Z-_]+)').findall(url)[0]
headersx = {'Referer': url, 'User-Agent': client.agent()}
page_data = client.request('https://vcstream.to/player?fid=%s&page=embed' % id, headers=headersx)
srcs = re.findall(r'sources:.\[(.*?)\]', page_data)[0]
srcs = srcs.replace('\\n','').replace('\\','')
srcs = '''[%s]''' % srcs
j_data = json.loads(srcs)
for j in j_data:
t = j['name']
label = j['label']
u = j['src']
if label.lower() == 'raw':
q = source_utils.check_sd_url(t)
else:
q = label
r = source_utils.check_sd_url_rip(t)
fs = client.getFileSize(u, retry429=True, headers=headers)
if fs == None or int(fs) == 0:
fs = client.getFileSize(u, retry429=True)
q = qual_based_on_fs(q,fs)
online = check(u)
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
if headers != None:
paramsx = {'headers':headers}
params = client.b64encode(json.dumps(paramsx, encoding='utf-8'))
items.append({'quality':q, 'riptype':r, 'src':u, 'fs':fs, 'online':online, 'params':params, 'urldata':urldata, 'allowsStreaming':True, 'allowsDownload':True})
elif '3donlinefilms.com' in url or '3dmoviesfullhd.com' in url or 'freedocufilms.com' in url:
data = urlparse.parse_qs(url)
headers = {}
if '3donlinefilms.com' in url:
headers['Referer'] = 'http://3donlinefilms.com'
l0 = 'https://3donlinefilms.com/update.php'
elif 'freedocufilms.com' in url:
headers['Referer'] = 'http://freedocufilms.com'
l0 = 'https://freedocufilms.com/update.php'
else:
headers['Referer'] = 'http://3dmoviesfullhd.com'
l0 = 'https://3dmoviesfullhd.com/update.php'
page = data['page'][0]
cook = client.request(page, output='cookie')
post_data = {'file':data['src_file'][0]}
cookie = '%s; zeroday=; visit=yes; jwplayer.qualityLabel=HD' % cook
headers['Referer'] = page
headers['User-Agent'] = client.agent()
headers['Cookie'] = cookie
u = data['file'][0]
u = u.replace('//freedocufilms','//www.freedocufilms')
try:
ret = client.request(l0, post=client.encodePostData(post_data),headers=headers, output='extended', XHR=True, cookie=cookie)
except Exception as e:
log(type='FAIL', method='process', err='%s' % e, dolog=False, logToControl=False, doPrint=True)
ret = client.request(u, output='headers', headers=headers, XHR=True)
try:
fs = int(re.findall(r'Content-Length:(.*)', str(ret), re.MULTILINE)[0].strip())
except:
fs = 0
q = qual_based_on_fs(q,fs)
online = False
if int(fs) > 0:
online = True
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
paramsx = {'headers':headers}
params = client.b64encode(json.dumps(paramsx, encoding='utf-8'))
items.append({'quality':q, 'riptype':r, 'src':url, 'fs':fs, 'online':online, 'params':params, 'urldata':urldata, 'allowsStreaming':False, 'allowsDownload':True})
elif 'cooltvseries.com' in url:
urlx = client.request(url, output='geturl', headers=headers)
urlx = '%s?e=file.mp4' % urlx
fs = client.getFileSize(url, retry429=True, headers=headers)
if fs == None or int(fs) == 0:
fs = client.getFileSize(url, retry429=True)
q = qual_based_on_fs(q,fs)
online = check(url)
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
if headers != None:
paramsx = {'headers':headers}
params = client.b64encode(json.dumps(paramsx, encoding='utf-8'))
allowsDownload = True
items.append({'quality':q, 'riptype':r, 'src':urlx, 'fs':fs, 'online':online, 'params':params, 'urldata':urldata, 'allowsStreaming':True, 'allowsDownload':allowsDownload})
else:
fs = client.getFileSize(url, retry429=True, headers=headers)
if fs == None or int(fs) == 0:
fs = client.getFileSize(url, retry429=True)
q = qual_based_on_fs(q,fs)
online = check(url)
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
if headers != None:
paramsx = {'headers':headers}
params = client.b64encode(json.dumps(paramsx, encoding='utf-8'))
allowsDownload = True
if '.m3u8' in url:
allowsDownload = False
items.append({'quality':q, 'riptype':r, 'src':url, 'fs':fs, 'online':online, 'params':params, 'urldata':urldata, 'allowsStreaming':True, 'allowsDownload':allowsDownload})
except Exception as e:
log(type='ERROR',method='process', err=u'%s' % e)
if len(items) == 0:
fs = client.getFileSize(url, retry429=True, headers=headers)
if fs == None or int(fs) == 0:
fs = client.getFileSize(url, retry429=True)
q = qual_based_on_fs(q,fs)
online = check(url)
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
if headers != None:
paramsx = {'headers':headers}
params = client.b64encode(json.dumps(paramsx, encoding='utf-8'))
items.append({'quality':q, 'riptype':r, 'src':url, 'fs':fs, 'online':online, 'params':params, 'urldata':urldata, 'allowsStreaming':True, 'allowsDownload':True})
return items
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)
titleinfo = txt
maininfo = ''
fs = 0
try:
furl, fs, file_ext1, err = mega.get_mega_dl_link(url)
if err != '':
raise Exception(err)
if file_ext1 != None:
file_ext = file_ext1
if file_ext not in ['.mp4','.mkv','.avi']:
titleinfo = '%s%s' % (txt+' ' if len(txt)>0 else '', file_ext+' file')
quality = qual_based_on_fs(quality, fs)
if int(fs) == 0:
fs = client.getFileSize(furl)
urldata = createurldata(furl, quality)
except Exception as e:
online = False
log('FAIL', 'createMeta-1', '%s - %s' % (url,e))
maininfo = '*File Unavailable*'
try:
log(type='INFO',method='createMeta', err=u'durl:%s ; res:%s; fs:%s' % (url,quality,fs))
files_ret.append({'source':self.name, 'maininfo':maininfo, 'titleinfo':titleinfo, 'quality':quality, 'vidtype':vidtype, 'rip':riptype, 'provider':provider, 'orig_url':orig_url, 'durl':url, 'url':url, 'urldata':urldata, 'params':params, 'logo':logo, 'allowsDownload':self.allowsDownload, 'resumeDownload':self.resumeDownload, 'allowsStreaming':self.allowsStreaming, 'online':online, 'key':key, 'enabled':True, 'fs':int(fs), 'file_ext':file_ext, 'ts':time.time(), 'lang':lang, 'sub_url':sub_url, 'poster':poster, 'subdomain':self.netloc[0], 'page_url':page_url, 'misc':{'player':'iplayer', 'gp':False}, 'seq':0})
except Exception as e:
log('ERROR', 'createMeta-2', '%s - %s' % (url,e))
files_ret.append({'source':urlhost, 'maininfo':maininfo, 'titleinfo':titleinfo, 'quality':quality, 'vidtype':vidtype, 'rip':'Unknown' ,'provider':provider, 'orig_url':orig_url, 'durl':url, 'url':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':self.netloc[0], 'page_url':page_url, 'misc':{'player':'iplayer', '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,
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 check(url, videoData=None, skipPageCheck=False, usePairing=True, embedpage=False, headers=None, cookie=None, session=None):
try:
retmsg = ''
fs = 0
result = None
sub_url = None
#ifstream = re.search('//.+?/(?:embed|f)/([0-9a-zA-Z-_]+)',(url)[0])
#if ifstream:
# return True
if videoData != None:
if 'File not found' in videoData or 'deleted by the owner' in videoData or 'Sorry!' in videoData:
log(type='FAIL', method='check', err='File deleted by the owner or was removed. : %s' % url)
return (False, videoData, 'File not found', fs, None, sub_url)
if '/stream/' not in url and '.oloadcdn.' not in url:
id = re.compile('//.+?/(?:embed|f)/([0-9a-zA-Z-_]+)').findall(url)[0]
url = 'https://openload.co/embed/%s/' % id
if skipPageCheck == False:
openloadhdrx = openloadhdr
if headers != None:
for key in headers.keys():
openloadhdrx[key] = headers[key]
videoData = client.request(url, headers=openloadhdrx, cookie=cookie)
if videoData == None:
log(type='FAIL', method='check', err='File deleted by the owner or was removed. : %s' % url)
return (False, videoData, 'File not found', fs, None, sub_url)
if 'File not found' in videoData or 'deleted by the owner' in videoData or 'Sorry!' in videoData:
log(type='FAIL', method='check', err='File deleted by the owner or was removed. : %s' % url)
return (False, videoData, 'File not found', fs, None, sub_url)
try:
fs = re.findall(r'window.filesize=(.*?);', videoData)[0]
except:
pass
if USE_OPENLOAD_SUB == True:
try:
sub_url_t = re.findall(r'suburl = \"(.*?)\";', videoData)[0]
sub_url_t = sub_url_t.replace('\\','')
sub_url_t = client.request(sub_url_t, headers=openloadhdrx, cookie=cookie)
if len(sub_url_t) > 50:
sub_url = sub_url_t
except:
sub_url = None
try:
if fs == 0:
vidData = client.request('https://openload.co/f/%s/' % id, headers=openloadhdr, cookie=cookie)
#print vidData
respD = client.parseDOM(vidData, 'div', attrs={'class': 'content-text'})[0]
#print respD
fs = re.findall(r':\ (.*?)\ ', respD)[0]
if 'gb' in respD.lower():
fs = int(float(fs.strip()) * (1024*1024*1024))
else:
fs = int(float(fs.strip()) * (1024*1024))
except:
pass
if embedpage == True:
return (True, videoData, retmsg, fs, None, sub_url)
# if openloadS is success then the stream would be available
result, videoData, retmsg = openloadS(url, videoData, usePairing=usePairing, session=session)
else:
result = url
try:
fs = client.getFileSize(url)
except:
fs = 0
if result == None:
if retmsg != '':
log(type='FAIL', method='check', err='%s : %s' % (retmsg, url))
return (False, videoData, retmsg, fs, result, sub_url)
if fs > 0:
return (True, videoData, retmsg, fs, result, sub_url)
else:
return (checkVidPresence(result), videoData, retmsg, fs, result, sub_url)
except:
return (False, videoData, retmsg, fs, result, sub_url)
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
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = client.b64encode(json.dumps('', encoding='utf-8'))
orig_url = url
online = check(url)
files_ret = []
titleinfo = txt
fs = 0
try:
furl, fs, file_ext = mega.get_mega_dl_link(url)
quality = qual_based_on_fs(quality, fs)
if int(fs) == 0:
fs = client.getFileSize(furl)
urldata = createurldata(furl, quality)
except Exception as e:
online = False
log('FAIL', 'createMeta-1', '%s - %s' % (url, e))
try:
files_ret.append({
'source': self.name,
'maininfo': '',
'titleinfo': titleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': riptype,
'provider': provider,
'durl': url,
'url': url,
'urldata': urldata,
'params': params,
'logo': logo,
'allowsDownload': self.allowsDownload,
'resumeDownload': self.resumeDownload,
'allowsStreaming': self.allowsStreaming,
'online': online,
'key': key,
'enabled': True,
'fs': int(fs),
'file_ext': file_ext,
'ts': time.time(),
'lang': lang,
'sub_url': sub_url,
'poster': poster,
'subdomain': self.netloc[0],
'misc': {
'player': 'iplayer',
'gp': False
}
})
except Exception as e:
log('ERROR', 'createMeta-2', '%s - %s' % (url, e))
files_ret.append({
'source': urlhost,
'maininfo': '',
'titleinfo': titleinfo,
'quality': quality,
'vidtype': vidtype,
'rip': 'Unknown',
'provider': provider,
'durl': url,
'url': 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': self.netloc[0],
'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 = []
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(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
ua = client.randomagent()
headers = {'Referer': 'https://vidnode.net/', 'User-Agent': 'Mozilla'}
urldata = client.b64encode(json.dumps('', encoding='utf-8'))
params = {'headers': headers, 'cookie': None}
params = json.dumps(params, encoding='utf-8')
params = client.b64encode(params)
online = check(url, headers=headers)
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 = []
#print vidurls
for vv in vidurls:
durl = vv['page']
vidurl, r1, r2 = resolve(durl, online)
print vidurl
if vidurl == None:
log(type='ERROR', method='createMeta', err=u'%s' % r1)
else:
quality = vv['label']
try:
online = check(vidurl, headers=headers)
fs = client.getFileSize(vidurl)
fs = int(fs)
except:
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):
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
