def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.FF_USER_AGENT}
html = self.net.http_GET(web_url, headers=headers).content
sources = helpers.scrape_sources(html)
if sources:
return helpers.pick_source(sources) + helpers.append_headers(
headers)
raise ResolverError('Video cannot be located.')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'Referer':'onlystream.tv','User-Agent':common.RAND_UA}
html = self.net.http_GET(web_url, headers=headers).content
r = re.search('sources: .{file:"(.+?)"', html, re.DOTALL)
headers = {'Referer':'https://onlystream.tv/'+media_id,'User-Agent':common.RAND_UA}
if r:return r.group(1) + helpers.append_headers(headers)
else:raise ResolverError('Video cannot be located.')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.IE_USER_AGENT, 'Referer': web_url}
html = self.net.http_GET(web_url, headers=headers).content
url = re.findall('src\s*:\s*\'(.+?)\'', html)
if url:
return url[-1] + helpers.append_headers(headers)
else:
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.RAND_UA}
html = self.net.http_GET(web_url, headers=headers).content
if html:
try:
headers.update({'Referer': web_url})
html = html.replace('\\', '')
pattern = r"""<video src="([^"]+)"""
link = re.search(pattern, html)
return urlparse.urljoin(
'http://www.girlfriendvideos.com',
link.groups()[0]) + helpers.append_headers(headers)
except:
raise ResolverError('File not found')
raise ResolverError('File not found')
def refresh_token(self):
client_id = self.get_setting('client_id')
client_secret = self.get_setting('client_secret')
refresh_token = self.get_setting('refresh')
logger.log_debug('Refreshing Expired Real Debrid Token: |%s|%s|' % (client_id, refresh_token))
if not self.__get_token(client_id, client_secret, refresh_token):
# empty all auth settings to force a re-auth on next use
self.reset_authorization()
raise ResolverError('Unable to Refresh Real Debrid Token')
def get_media_url(self, host, media_id):
result = self.__check_auth(media_id)
if not result:
result = self.__auth_ip(media_id)
if result:
return helpers.pick_source(list(result.items())) + helpers.append_headers(self.headers)
raise ResolverError(i18n('no_ip_authorization'))
def get_media_url(self, host, media_id):
if( '/l/' in self.web_url ):
response = self.get_media_url_list( host, media_id )
else:
response = self.get_media_url_file( host, media_id )
if( response != False ):
return response
raise ResolverError('Unable to locate video')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'Referer': web_url, 'User-Agent': common.FF_USER_AGENT}
html = self.net.http_GET(web_url, headers=headers).content
if "unable to find the video" in html:
raise ResolverError(
'The requested video was not found or may have been removed.')
match = re.search(r'(\$=.+?;)\s*<', html, re.DOTALL)
if match:
sdata = self.decode(match.group(1))
if sdata:
s = re.search(r"src',\s*'([^']+)", sdata)
if s:
return s.group(1) + helpers.append_headers(headers)
raise ResolverError('Video Link Not Found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.IOS_USER_AGENT, 'Referer': web_url}
stream_url = ''
new_host = urlparse(web_url).netloc
html = self.net.http_GET(web_url, headers=headers).content
if 'videozoo' not in new_host:
r = re.search(
'(?:playlist:|timer\s*=\s*null;).+?url\s*[:=]+\s*[\'"]+(.+?)[\'"]+',
html, re.DOTALL)
else:
r = re.search('\*/\s+?(eval\(function\(p,a,c,k,e,d\).+)\s+?/\*',
html)
if r:
try:
r = jsunpack.unpack(r.group(1))
if r:
r = re.search('\[{"url":"(.+?)"', r.replace('\\', ''))
except:
if r:
re_src = re.search('urlResolvers\|2F(.+?)\|',
r.group(1))
re_url = re.search('php\|3D(.+?)\|', r.group(1))
if re_src and re_url:
stream_url = 'http://%s/%s.php?url=%s' % (
new_host, re_src.group(1), re_url.group(1))
stream_url = self._redirect_test(stream_url)
else:
raise ResolverError('File not found')
if r:
stream_url = urllib.unquote_plus(r.group(1))
if 'http' not in stream_url:
stream_url = 'http://' + host + '/' + stream_url.replace(
'/gplus.php', 'gplus.php').replace('/picasa.php',
'picasa.php')
stream_url = self._redirect_test(stream_url)
if stream_url:
if 'google' in stream_url:
return HostedMediaFile(url=stream_url).resolve()
else:
return stream_url
else:
raise ResolverError('File not found')
def get_media_url(url, media_id):
headers = {'User-Agent': common.RAND_UA}
html = net.http_GET(url, headers=headers).content
if html:
html = html.encode('utf-8')
aa_text = re.findall("""(ﾟωﾟﾉ\s*=\s*/｀ｍ´\s*）\s*ﾉ.+?)</SCRIPT>""", html,
re.I)
if aa_text:
try:
aa_decoded = ''
for i in aa_text:
try:
aa_decoded += str(
aa_decoder.AADecoder(
re.sub(
'\(+ﾟДﾟ\)+\s*\[ﾟoﾟ\]\)*\s*\+(.+?)\(+ﾟДﾟ\s*\)+\[ﾟoﾟ\]\)+',
r'(ﾟДﾟ)[ﾟoﾟ]+\1(ﾟДﾟ)[ﾟoﾟ])', i)).decode())
except:
pass
href = re.search('''location.*?\"(.*)\"''', aa_decoded)
if href:
href = href.group(1)
if href.startswith("http"): location = href
elif href.startswith("//"): location = "http:%s" % href
else: location = "http://www.speedvid.net%s" % href
headers.update({
'Referer':
url,
'Cookie':
str((int(math.floor((900 - 100) * random()) + 100)) *
(int(time.time())) * (128 / 8))
})
_html = net.http_GET(location, headers=headers).content
sources = re.search("""file : '(.*)'""", _html)
sources = sources.group(1)
if sources:
del headers['Cookie']
headers.update({'Referer': location})
return str(sources) + "|User-Agent=Mozilla/5.0"
except Exception as e:
raise ResolverError(e)
raise ResolverError('File not found')
def api_call(self, method, data, http='GET', session=True, refresh=True):
loop = 0
while loop < 2:
loop += 1
if session:
data.update({'sid': self._session_id})
try:
if http == 'GET':
content = self.net.http_GET(
self.api_base + method + '?' +
urllib_parse.urlencode(data)).content
elif http == 'HEAD':
content = self.net.http_HEAD(
self.api_base + method + '?' +
urllib_parse.urlencode(data)).content
elif http == 'POST':
content = self.net.http_POST(
self.api_base + method,
urllib_parse.urlencode(data)).content
else:
raise ResolverError(self.name + ' Bad Request')
content = json.loads(content)
status = int(content['response_status'])
response = content['response']
except urllib_error.HTTPError as e:
status, response = e.code, []
except ResolverError:
raise
except:
raise ResolverError(self.name + ' Bad Response')
if status == 200:
return response
if session and refresh and status in [
401, 402
]: # only actually seen 401, although 402 seems plausible
self.refresh_session()
continue
raise ResolverError(self.name + ' HTTP ' + str(status) + ' Error')
def get_hosts(self):
_hosts = []
disabled = []
cached = []
try:
if self.get_setting('torrents') == 'true':
_hosts.extend(['torrent', 'magnet'])
response = self.net.http_GET(filehosts,
headers=self.headers).content
res = json.loads(response)
if res.get('status') != 'OK':
raise ResolverError('Server did not return hosts list')
result = iter(list(res.get('return').items()))
for h, d in result:
if d['Status'] == '0':
disabled.append(h)
continue
elif h == 'mp3':
continue
elif d['iscacheable'] == 1:
cached.append(h)
_hosts.append(h)
if 'alias' in d:
for a in d['alias']:
_hosts.append(a)
logger.log_debug(
'Linksnappy.com available hosts: {0}'.format(_hosts))
logger.log_debug(
'Linksnappy.com hosts supporting cache: {0}'.format(cached))
if disabled:
logger.log_debug(
'Linksnappy.com currently disabled hosts: {0}'.format(
disabled))
return _hosts, cached
except Exception as e:
logger.log_error('Error getting Linksnappy hosts: {0}'.format(e))
return [], []
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.RAND_UA}
request = urllib2.Request(web_url, headers=headers)
response = urllib2.urlopen(request, context=self.context)
html = response.read()
if html:
try:
headers.update({'Referer': web_url})
source = re.search('''file:\s*["']([^"']+)''',
html).groups()[0]
return source + helpers.append_headers(headers)
except:
raise ResolverError('File not found')
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.RAND_UA,
'Referer': 'https://{0}/'.format(host)}
resp = self.net.http_GET(web_url, headers=headers).content
resp = json.loads(resp)[0]
if resp.get('video_url'):
return 'https://{0}{1}'.format(host, self._decode(resp.get('video_url'))) + helpers.append_headers(headers)
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
html = self.net.http_GET(web_url).content
direct_url = re.search('m4v\s*:\s*["\']([^"\']+)', html)
if direct_url:
return direct_url.group(1)
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.RAND_UA,
'Referer': 'https://video.sibnet.ru/'}
html = self.net.http_GET(web_url, headers=headers).content
source = re.search(r'src:\s*"([^"]+)', html)
if source:
return 'https://video.sibnet.ru' + source.group(1) + helpers.append_headers(headers)
raise ResolverError('Video not found')
def get_media_url(self, host, media_id):
cached = self.__check_cache(media_id)
if cached:
logger.log_debug('Premiumize.me: %s is readily available to stream' % media_id)
url = '%s://api.premiumize.me/pm-api/v1.php?' % self.scheme
query = urllib.urlencode({'method': 'directdownloadlink', 'params[login]': self.username, 'params[pass]': self.password, 'params[link]': media_id})
url = url + query
response = self.net.http_GET(url).content
response = json.loads(response)
if 'status' in response:
if response['status'] == 200:
link = response['result']['location']
else:
raise ResolverError('Link Not Found: Error Code: %s' % response['status'])
else:
raise ResolverError('Unexpected Response Received')
logger.log_debug('Premiumize.me: Resolved to %s' % link)
return link
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'Referer': web_url}
headers.update(self.headers)
html = self.net.http_GET(web_url, headers=headers).content
sources = helpers.scrape_sources(
html, patterns=["""file:\s*["'](?P<url>[^"']+)"""])
if sources:
auth = self.__check_auth(media_id)
if not auth:
auth = self.__auth_ip(media_id)
if auth:
return helpers.pick_source(sources) + helpers.append_headers(
headers)
else:
raise ResolverError(i18n('no_ip_authorization'))
else:
raise ResolverError('Unable to locate links')
def get_media_url(self, host, media_id):
try:
headers = {'User-Agent': common.RAND_UA}
web_url = self.get_url(host, media_id)
html = self.net.http_GET(web_url, headers=headers).content
if html:
sources = re.findall(
'''['"]file['"]:\s*['"](?P<label>[^'"]+)['"],\s*['"]type['"]:\s*['"](?P<url>[^'"]+)["']''',
html, re.DOTALL)
sources = [(i[1], i[0]) for i in sorted(sources)]
return self.net.http_GET(helpers.pick_source(sources),
headers=headers).get_url(
) + helpers.append_headers(headers)
raise ResolverError('File not found')
except:
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
resp = self.net.http_GET(web_url)
html = resp.content
r = re.search('file: "(.+?)",', html)
if r:
return r.group(1)
else:
raise ResolverError('File Not Found or removed')
def get_media_url(self, host, media_id, retry=False):
try:
url = 'https://api.real-debrid.com/rest/1.0/unrestrict/link'
headers = self.headers
headers['Authorization'] = 'Bearer %s' % (
self.get_setting('token'))
data = {'link': media_id}
result = self.net.http_POST(url, form_data=data,
headers=headers).content
except urllib2.HTTPError as e:
if not retry and e.code == 401:
if self.get_setting('refresh'):
self.refresh_token()
return self.get_media_url(host, media_id, retry=True)
else:
self.reset_authorization()
raise ResolverError(
'Real Debrid Auth Failed & No Refresh Token')
else:
try:
js_result = json.loads(e.read())
if 'error' in js_result:
msg = js_result['error']
else:
msg = 'Unknown Error (1)'
except:
msg = 'Unknown Error (2)'
raise ResolverError('Real Debrid Error: %s (%s)' %
(msg, e.code))
except Exception as e:
raise ResolverError(
'Unexpected Exception during RD Unrestrict: %s' % (e))
else:
js_result = json.loads(result)
links = []
link = self.__get_link(js_result)
if link is not None: links.append(link)
if 'alternative' in js_result:
for alt in js_result['alternative']:
link = self.__get_link(alt)
if link is not None: links.append(link)
return helpers.pick_source(links)
def get_media_url(self, host, media_id):
result = self.__auth_ip(media_id)
if 'vt' in result:
vt = result['vt']
del result['vt']
return helpers.pick_source(
result.items()) + '?' + urllib.urlencode(
{'vt': vt}) + helpers.append_headers(self.headers)
else:
raise ResolverError('Video Token Missing')
def __check_auth(self, media_id):
common.logger.log('Checking Auth: %s' % (media_id))
url = 'http://api.streamin.to/pair/check.php'
try:
js_result = json.loads(
self.net.http_GET(url, headers=self.headers).content)
except ValueError:
raise ResolverError('Unusable Authorization Response')
common.logger.log('Auth Result: %s' % (js_result))
return js_result.get('status') == 200
def refresh_token(self):
REFRESH_TOKEN = self.get_setting('refresh')
logger.log_debug('Refreshing Expired Debrid-Link Token: |{0}|'.format(
REFRESH_TOKEN))
try:
url = '{0}/oauth/token'.format(api_url[:-3])
data = {
'client_id': CLIENT_ID,
'refresh_token': REFRESH_TOKEN,
'grant_type': 'refresh_token'
}
if self.headers.get('Authorization', False):
self.headers.pop('Authorization')
js_result = json.loads(
self.net.http_POST(url, form_data=data,
headers=self.headers).content)
if js_result.get('access_token', False):
self.set_setting('token', js_result.get('access_token'))
self.headers.update({
'Authorization':
'Bearer {0}'.format(js_result.get('access_token'))
})
return True
else:
# empty all auth settings to force a re-auth on next use
self.reset_authorization()
raise ResolverError('Unable to Refresh Debrid-Link Token')
except urllib_error.HTTPError as e:
if e.code == 400:
js_data = json.loads(e.read())
if js_data.get('error') == 'invalid_request':
logger.log_debug('Exception during DL auth: {0}'.format(
js_data.get('error')))
# empty all auth settings to force a re-auth on next use
self.reset_authorization()
raise ResolverError('Unknown error during Authorization')
else:
logger.log_debug('Exception during DL auth: {0}'.format(e))
raise ResolverError('Unknown error during Authorization')
except Exception as e:
self.reset_authorization()
logger.log_debug('Debrid-Link Authorization Failed: {0}'.format(e))
return False
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'Cookie': 'ref_url=http%3A%2F%2Fwww.movieswatch.com.pk%2F',
'User-Agent': common.RAND_UA}
html = self.net.http_GET(web_url, headers=headers).content
sources = helpers.scrape_sources(html)
if sources:
headers.pop('Cookie')
return helpers.pick_source(sources) + helpers.append_headers(headers)
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.RAND_UA}
html = self.net.http_GET(web_url, headers=headers).content
if html:
try:
data = re.search("""window\.__data\s*=\s*({.+?});""", html).groups()[0]
data = json.loads(data)
stream_url = data["video"]["byId"][media_id]["url"].replace("\\u002F", "/")
if stream_url.startswith("//"): stream_url = "http:%s" % stream_url
headers.update({"Referer": web_url})
if stream_url: return stream_url + helpers.append_headers(headers)
except:
raise ResolverError('File not found')
raise ResolverError('File not found')
def get_all_hosters(self, retry=False):
hosters = []
url = '{0}/downloader/regex'.format(api_url)
try:
js_data = json.loads(
self.net.http_GET(url, headers=self.headers).content)
if js_data.get('success', False):
js_data = js_data.get('value')
regexes = [value.get('regexs')[0] for value in js_data]
logger.log_debug('Debrid-Link regexes : {0}'.format(
len(regexes)))
for regex in regexes:
try:
hosters.append(re.compile(regex))
except:
pass
logger.log_debug('Debrid-Link hosters : {0}'.format(
len(hosters)))
else:
logger.log_error('Error getting DL Hosters')
except urllib_error.HTTPError as e:
if not retry and e.code == 401:
if self.get_setting('refresh'):
self.refresh_token()
return self.get_all_hosters(retry=True)
else:
self.reset_authorization()
raise ResolverError(
'Debrid-Link Auth Failed & No Refresh Token')
else:
try:
js_result = json.loads(e.read())
if 'error' in js_result:
msg = js_result.get('error')
else:
msg = 'Unknown Error (1)'
except:
msg = 'Unknown Error (2)'
raise ResolverError('Debrid-Link Error: {0} ({1})'.format(
msg, e.code))
except Exception as e:
logger.log_error('Error getting DL Hosters: {0}'.format(e))
return hosters
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.RAND_UA}
html = self.net.http_GET(web_url, headers=headers).content
r = re.search(r'''video_url:\s*['"]([^"']+)''', html, re.DOTALL)
if r:
headers.update({'Referer': web_url})
return r.group(1) + helpers.append_headers(headers)
raise ResolverError('File not found')
def get_media_url(self, host, media_id):
web_url = self.get_url(host, media_id)
headers = {'User-Agent': common.FF_USER_AGENT}
html = self.net.http_GET(web_url, headers=headers).content
if html:
try:
json_data = re.search(r"""__AS_INITIAL_DATA__\s*=\s*({.*?});""", html).groups()[0]
json_data = json_data.replace(r"\/", "/")
a = json.loads(json_data)
ep_id = a["show"]["sluggedVideo"]["id"]
api_url = 'http://www.adultswim.com/videos/api/v0/assets?platform=desktop&id=%s&phds=true' % ep_id
return helpers.get_media_url(api_url, patterns=[r"""<file .*?type="(?P<label>[^"]+).+?>(?P<url>[^<\s]+)"""], result_blacklist=[".f4m"]).replace(' ', '%20')
except Exception as e:
raise ResolverError(e)
raise ResolverError('Video not found')
def get_media_url(self, host, media_id):
headers = {'User-Agent': common.RAND_UA}
web_url = self.get_url(host, media_id)
html = self.net.http_GET(web_url, headers=headers).content
r = re.search(r'''<source\s*src=['"]([^"']+)''', html, re.DOTALL)
if r:
headers.update({'Referer': web_url})
return urllib_parse.urljoin('https://www.vrsmash.com', r.group(1)) + helpers.append_headers(headers)
raise ResolverError('File not found')
