test
This commit is contained in:
Pavel Suha
577
lib/server/youtuberesolver.py
Normal file
577
lib/server/youtuberesolver.py
Normal file
@@ -0,0 +1,577 @@
|
||||
# -*- coding: UTF-8 -*-
|
||||
import operator
|
||||
|
||||
|
||||
#source from https://github.com/rg3/youtube-dl/blob/master/youtube_dl/utils.py
|
||||
class ExtractorError(Exception):
|
||||
"""Error during info extraction."""
|
||||
|
||||
def __init__(self, msg, tb=None, expected=False, cause=None, video_id=None):
|
||||
""" tb, if given, is the original traceback (so that it can be printed out).
|
||||
If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
|
||||
"""
|
||||
|
||||
if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
|
||||
expected = True
|
||||
if video_id is not None:
|
||||
msg = video_id + ': ' + msg
|
||||
if cause:
|
||||
msg += ' (caused by %r)' % cause
|
||||
if not expected:
|
||||
msg += bug_reports_message()
|
||||
super(ExtractorError, self).__init__(msg)
|
||||
|
||||
self.traceback = tb
|
||||
self.exc_info = sys.exc_info() # preserve original exception
|
||||
self.cause = cause
|
||||
self.video_id = video_id
|
||||
|
||||
def format_traceback(self):
|
||||
if self.traceback is None:
|
||||
return None
|
||||
return ''.join(traceback.format_tb(self.traceback))
|
||||
|
||||
_OPERATORS = [
|
||||
('|', operator.or_),
|
||||
('^', operator.xor),
|
||||
('&', operator.and_),
|
||||
('>>', operator.rshift),
|
||||
('<<', operator.lshift),
|
||||
('-', operator.sub),
|
||||
('+', operator.add),
|
||||
('%', operator.mod),
|
||||
('/', operator.truediv),
|
||||
('*', operator.mul),
|
||||
]
|
||||
_ASSIGN_OPERATORS = [(op + '=', opfunc) for op, opfunc in _OPERATORS]
|
||||
_ASSIGN_OPERATORS.append(('=', lambda cur, right: right))
|
||||
|
||||
_NAME_RE = r'[a-zA-Z_$][a-zA-Z_$0-9]*'
|
||||
|
||||
|
||||
# source from https://github.com/rg3/youtube-dl/blob/master/youtube_dl/jsinterp.py
|
||||
class JSInterpreter(object):
|
||||
def __init__(self, code, objects=None):
|
||||
if objects is None:
|
||||
objects = {}
|
||||
self.code = code
|
||||
self._functions = {}
|
||||
self._objects = objects
|
||||
|
||||
def remove_quotes(self, s):
|
||||
if s is None or len(s) < 2:
|
||||
return s
|
||||
for quote in ('"', "'", ):
|
||||
if s[0] == quote and s[-1] == quote:
|
||||
return s[1:-1]
|
||||
return s
|
||||
|
||||
def interpret_statement(self, stmt, local_vars, allow_recursion=100):
|
||||
if allow_recursion < 0:
|
||||
raise ExtractorError('Recursion limit reached')
|
||||
|
||||
should_abort = False
|
||||
stmt = stmt.lstrip()
|
||||
stmt_m = re.match(r'var\s', stmt)
|
||||
if stmt_m:
|
||||
expr = stmt[len(stmt_m.group(0)):]
|
||||
else:
|
||||
return_m = re.match(r'return(?:\s+|$)', stmt)
|
||||
if return_m:
|
||||
expr = stmt[len(return_m.group(0)):]
|
||||
should_abort = True
|
||||
else:
|
||||
# Try interpreting it as an expression
|
||||
expr = stmt
|
||||
|
||||
v = self.interpret_expression(expr, local_vars, allow_recursion)
|
||||
return v, should_abort
|
||||
|
||||
def interpret_expression(self, expr, local_vars, allow_recursion):
|
||||
expr = expr.strip()
|
||||
if expr == '': # Empty expression
|
||||
return None
|
||||
|
||||
if expr.startswith('('):
|
||||
parens_count = 0
|
||||
for m in re.finditer(r'[()]', expr):
|
||||
if m.group(0) == '(':
|
||||
parens_count += 1
|
||||
else:
|
||||
parens_count -= 1
|
||||
if parens_count == 0:
|
||||
sub_expr = expr[1:m.start()]
|
||||
sub_result = self.interpret_expression(
|
||||
sub_expr, local_vars, allow_recursion)
|
||||
remaining_expr = expr[m.end():].strip()
|
||||
if not remaining_expr:
|
||||
return sub_result
|
||||
else:
|
||||
expr = json.dumps(sub_result) + remaining_expr
|
||||
break
|
||||
else:
|
||||
raise ExtractorError('Premature end of parens in %r' % expr)
|
||||
|
||||
for op, opfunc in _ASSIGN_OPERATORS:
|
||||
m = re.match(r'''(?x)
|
||||
(?P<out>%s)(?:\[(?P<index>[^\]]+?)\])?
|
||||
\s*%s
|
||||
(?P<expr>.*)$''' % (_NAME_RE, re.escape(op)), expr)
|
||||
if not m:
|
||||
continue
|
||||
right_val = self.interpret_expression(
|
||||
m.group('expr'), local_vars, allow_recursion - 1)
|
||||
|
||||
if m.groupdict().get('index'):
|
||||
lvar = local_vars[m.group('out')]
|
||||
idx = self.interpret_expression(
|
||||
m.group('index'), local_vars, allow_recursion)
|
||||
assert isinstance(idx, int)
|
||||
cur = lvar[idx]
|
||||
val = opfunc(cur, right_val)
|
||||
lvar[idx] = val
|
||||
return val
|
||||
else:
|
||||
cur = local_vars.get(m.group('out'))
|
||||
val = opfunc(cur, right_val)
|
||||
local_vars[m.group('out')] = val
|
||||
return val
|
||||
|
||||
if expr.isdigit():
|
||||
return int(expr)
|
||||
|
||||
var_m = re.match(
|
||||
r'(?!if|return|true|false)(?P<name>%s)$' % _NAME_RE,
|
||||
expr)
|
||||
if var_m:
|
||||
return local_vars[var_m.group('name')]
|
||||
|
||||
try:
|
||||
return json.loads(expr)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
m = re.match(
|
||||
r'(?P<in>%s)\[(?P<idx>.+)\]$' % _NAME_RE, expr)
|
||||
if m:
|
||||
val = local_vars[m.group('in')]
|
||||
idx = self.interpret_expression(
|
||||
m.group('idx'), local_vars, allow_recursion - 1)
|
||||
return val[idx]
|
||||
|
||||
m = re.match(
|
||||
r'(?P<var>%s)(?:\.(?P<member>[^(]+)|\[(?P<member2>[^]]+)\])\s*(?:\(+(?P<args>[^()]*)\))?$' % _NAME_RE,
|
||||
expr)
|
||||
if m:
|
||||
variable = m.group('var')
|
||||
member = self.remove_quotes(m.group('member') or m.group('member2'))
|
||||
arg_str = m.group('args')
|
||||
|
||||
if variable in local_vars:
|
||||
obj = local_vars[variable]
|
||||
else:
|
||||
if variable not in self._objects:
|
||||
self._objects[variable] = self.extract_object(variable)
|
||||
obj = self._objects[variable]
|
||||
|
||||
if arg_str is None:
|
||||
# Member access
|
||||
if member == 'length':
|
||||
return len(obj)
|
||||
return obj[member]
|
||||
|
||||
assert expr.endswith(')')
|
||||
# Function call
|
||||
if arg_str == '':
|
||||
argvals = tuple()
|
||||
else:
|
||||
argvals = tuple([
|
||||
self.interpret_expression(v, local_vars, allow_recursion)
|
||||
for v in arg_str.split(',')])
|
||||
|
||||
if member == 'split':
|
||||
assert argvals == ('',)
|
||||
return list(obj)
|
||||
if member == 'join':
|
||||
assert len(argvals) == 1
|
||||
return argvals[0].join(obj)
|
||||
if member == 'reverse':
|
||||
assert len(argvals) == 0
|
||||
obj.reverse()
|
||||
return obj
|
||||
if member == 'slice':
|
||||
assert len(argvals) == 1
|
||||
return obj[argvals[0]:]
|
||||
if member == 'splice':
|
||||
assert isinstance(obj, list)
|
||||
index, howMany = argvals
|
||||
res = []
|
||||
for i in range(index, min(index + howMany, len(obj))):
|
||||
res.append(obj.pop(index))
|
||||
return res
|
||||
|
||||
return obj[member](argvals)
|
||||
|
||||
for op, opfunc in _OPERATORS:
|
||||
m = re.match(r'(?P<x>.+?)%s(?P<y>.+)' % re.escape(op), expr)
|
||||
if not m:
|
||||
continue
|
||||
x, abort = self.interpret_statement(
|
||||
m.group('x'), local_vars, allow_recursion - 1)
|
||||
if abort:
|
||||
raise ExtractorError(
|
||||
'Premature left-side return of %s in %r' % (op, expr))
|
||||
y, abort = self.interpret_statement(
|
||||
m.group('y'), local_vars, allow_recursion - 1)
|
||||
if abort:
|
||||
raise ExtractorError(
|
||||
'Premature right-side return of %s in %r' % (op, expr))
|
||||
return opfunc(x, y)
|
||||
|
||||
m = re.match(
|
||||
r'^(?P<func>%s)\((?P<args>[a-zA-Z0-9_$,]*)\)$' % _NAME_RE, expr)
|
||||
if m:
|
||||
fname = m.group('func')
|
||||
argvals = tuple([
|
||||
int(v) if v.isdigit() else local_vars[v]
|
||||
for v in m.group('args').split(',')]) if len(m.group('args')) > 0 else tuple()
|
||||
if fname not in self._functions:
|
||||
self._functions[fname] = self.extract_function(fname)
|
||||
return self._functions[fname](argvals)
|
||||
|
||||
raise ExtractorError('Unsupported JS expression %r' % expr)
|
||||
|
||||
def extract_object(self, objname):
|
||||
_FUNC_NAME_RE = r'''(?:[a-zA-Z$0-9]+|"[a-zA-Z$0-9]+"|'[a-zA-Z$0-9]+')'''
|
||||
obj = {}
|
||||
obj_m = re.search(
|
||||
r'''(?x)
|
||||
(?<!this\.)%s\s*=\s*{\s*
|
||||
(?P<fields>(%s\s*:\s*function\s*\(.*?\)\s*{.*?}(?:,\s*)?)*)
|
||||
}\s*;
|
||||
''' % (re.escape(objname), _FUNC_NAME_RE),
|
||||
self.code)
|
||||
fields = obj_m.group('fields')
|
||||
# Currently, it only supports function definitions
|
||||
fields_m = re.finditer(
|
||||
r'''(?x)
|
||||
(?P<key>%s)\s*:\s*function\s*\((?P<args>[a-z,]+)\){(?P<code>[^}]+)}
|
||||
''' % _FUNC_NAME_RE,
|
||||
fields)
|
||||
for f in fields_m:
|
||||
argnames = f.group('args').split(',')
|
||||
obj[self.remove_quotes(f.group('key'))] = self.build_function(argnames, f.group('code'))
|
||||
|
||||
return obj
|
||||
|
||||
def extract_function(self, funcname):
|
||||
func_m = re.search(
|
||||
r'''(?x)
|
||||
(?:function\s+%s|[{;,]\s*%s\s*=\s*function|var\s+%s\s*=\s*function)\s*
|
||||
\((?P<args>[^)]*)\)\s*
|
||||
\{(?P<code>[^}]+)\}''' % (
|
||||
re.escape(funcname), re.escape(funcname), re.escape(funcname)),
|
||||
self.code)
|
||||
if func_m is None:
|
||||
raise ExtractorError('Could not find JS function %r' % funcname)
|
||||
argnames = func_m.group('args').split(',')
|
||||
|
||||
return self.build_function(argnames, func_m.group('code'))
|
||||
|
||||
def call_function(self, funcname, *args):
|
||||
f = self.extract_function(funcname)
|
||||
return f(args)
|
||||
|
||||
def build_function(self, argnames, code):
|
||||
def resf(args):
|
||||
local_vars = dict(list(zip(argnames, args)))
|
||||
for stmt in code.split(';'):
|
||||
res, abort = self.interpret_statement(stmt, local_vars)
|
||||
if abort:
|
||||
break
|
||||
return res
|
||||
return resf
|
||||
|
||||
|
||||
# inspired by https://github.com/rg3/youtube-dl/blob/master/youtube_dl/extractor/youtube.py
|
||||
import urllib.request, urllib.error, urllib.parse
|
||||
class SignatureExtractor:
|
||||
|
||||
def __init__(self):
|
||||
self.algoCache = {}
|
||||
|
||||
def decryptSignature(self, s, playerUrl):
|
||||
util.debug("decrypt_signature sign_len[%d] playerUrl[%s]" % (len(s), playerUrl))
|
||||
|
||||
if playerUrl is None:
|
||||
raise ExtractorError('Cannot decrypt signature without playerUrl')
|
||||
|
||||
if playerUrl.startswith('//'):
|
||||
playerUrl = 'https:' + playerUrl
|
||||
elif playerUrl.startswith('/'):
|
||||
playerUrl = 'https://youtube.com' + playerUrl
|
||||
|
||||
# use algoCache
|
||||
if playerUrl not in self.algoCache:
|
||||
# get player HTML 5 sript
|
||||
request = urllib.request.Request(playerUrl)
|
||||
try:
|
||||
self.playerData = urllib.request.urlopen(request).read()
|
||||
self.playerData = self.playerData.decode('utf-8', 'ignore')
|
||||
except:
|
||||
util.debug('Unable to download playerUrl webpage')
|
||||
return ''
|
||||
|
||||
patterns = [
|
||||
r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
|
||||
# Obsolete patterns
|
||||
r'(["\'])signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
|
||||
r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('
|
||||
]
|
||||
|
||||
match = None
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, self.playerData)
|
||||
if match is not None:
|
||||
break
|
||||
|
||||
if match:
|
||||
mainFunName = match.group('sig')
|
||||
util.debug('Main signature function name = "%s"' % mainFunName)
|
||||
else:
|
||||
util.debug('Can not get main signature function name')
|
||||
return ''
|
||||
|
||||
jsi = JSInterpreter(self.playerData)
|
||||
initial_function = jsi.extract_function(mainFunName)
|
||||
algoCodeObj = lambda s: initial_function([s])
|
||||
else:
|
||||
# get algoCodeObj from algoCache
|
||||
util.debug('Algo taken from cache')
|
||||
algoCodeObj = self.algoCache[playerUrl]
|
||||
|
||||
signature = algoCodeObj(s)
|
||||
|
||||
util.debug('Decrypted signature = [%s]' % signature)
|
||||
# if algo seems ok and not in cache, add it to cache
|
||||
if playerUrl not in self.algoCache and '' != signature:
|
||||
util.debug('Algo from player [%s] added to cache' % playerUrl)
|
||||
self.algoCache[playerUrl] = algoCodeObj
|
||||
|
||||
return signature
|
||||
|
||||
decryptor = SignatureExtractor()
|
||||
|
||||
'''
|
||||
YouTube plugin for XBMC
|
||||
Copyright (C) 2010-2012 Tobias Ussing And Henrik Mosgaard Jensen
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
'''
|
||||
|
||||
import sys
|
||||
import cgi
|
||||
import json
|
||||
|
||||
class YoutubePlayer(object):
|
||||
fmt_value = {
|
||||
5: "240p",
|
||||
18: "360p",
|
||||
22: "720p",
|
||||
26: "???",
|
||||
33: "???",
|
||||
34: "360p",
|
||||
35: "480p",
|
||||
37: "1080p",
|
||||
38: "720p",
|
||||
43: "360p",
|
||||
44: "480p",
|
||||
45: "720p",
|
||||
46: "520p",
|
||||
59: "480",
|
||||
78: "400",
|
||||
82: "360p",
|
||||
83: "240p",
|
||||
84: "720p",
|
||||
85: "520p",
|
||||
100: "360p",
|
||||
101: "480p",
|
||||
102: "720p",
|
||||
120: "hd720",
|
||||
121: "hd1080"
|
||||
}
|
||||
|
||||
# YouTube Playback Feeds
|
||||
urls = {}
|
||||
urls['video_stream'] = "http://www.youtube.com/watch?v=%s&safeSearch=none"
|
||||
urls['embed_stream'] = "http://www.youtube.com/embed/%s"
|
||||
urls['video_info'] = "http://www.youtube.com/get_video_info?video_id=%s" \
|
||||
"&eurl=https://youtube.googleapis.com/v/%s&sts=%s"
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def removeAdditionalEndingDelimiter(self, data):
|
||||
pos = data.find("};")
|
||||
if pos != -1:
|
||||
data = data[:pos + 1]
|
||||
return data
|
||||
|
||||
def extractFlashVars(self, data, assets):
|
||||
flashvars = {}
|
||||
found = False
|
||||
|
||||
for line in data.split("\n"):
|
||||
if line.strip().find(";ytplayer.config = ") > 0:
|
||||
found = True
|
||||
p1 = line.find(";ytplayer.config = ") + len(";ytplayer.config = ") - 1
|
||||
p2 = line.rfind(";")
|
||||
if p1 <= 0 or p2 <= 0:
|
||||
continue
|
||||
data = line[p1 + 1:p2]
|
||||
break
|
||||
data = self.removeAdditionalEndingDelimiter(data)
|
||||
|
||||
if found:
|
||||
data = json.loads(data)
|
||||
if assets:
|
||||
flashvars = data["assets"]
|
||||
else:
|
||||
flashvars = data["args"]
|
||||
return flashvars
|
||||
|
||||
def scrapeWebPageForVideoLinks(self, result, video, video_id):
|
||||
links = {}
|
||||
if re.search(r'player-age-gate-content">', result) is not None:
|
||||
# We simulate the access to the video from www.youtube.com/v/{video_id}
|
||||
# this can be viewed without login into Youtube
|
||||
embed_webpage = util.request(self.urls["embed_stream"] % video_id)
|
||||
|
||||
sts = re.search('"sts"\s*:\s*(\d+)', embed_webpage).group().replace('"sts":', '')
|
||||
result = util.request(self.urls["video_info"] % (video_id, video_id, sts))
|
||||
|
||||
flashvars = cgi.parse_qs(result)
|
||||
flashvars["url_encoded_fmt_stream_map"] = flashvars["url_encoded_fmt_stream_map"][0]
|
||||
flashvars["title"] = flashvars["title"][0]
|
||||
else:
|
||||
flashvars = self.extractFlashVars(result, 0)
|
||||
|
||||
if "url_encoded_fmt_stream_map" not in flashvars:
|
||||
return links
|
||||
|
||||
if "ttsurl" in flashvars:
|
||||
video["ttsurl"] = flashvars["ttsurl"]
|
||||
if "title" in flashvars:
|
||||
video["title"] = flashvars["title"]
|
||||
|
||||
for url_desc in flashvars["url_encoded_fmt_stream_map"].split(","):
|
||||
url_desc_map = cgi.parse_qs(url_desc)
|
||||
if not ("url" in url_desc_map or "stream" in url_desc_map):
|
||||
continue
|
||||
|
||||
key = int(url_desc_map["itag"][0])
|
||||
url = ""
|
||||
if "url" in url_desc_map:
|
||||
url = urllib.parse.unquote(url_desc_map["url"][0])
|
||||
elif "conn" in url_desc_map and "stream" in url_desc_map:
|
||||
url = urllib.parse.unquote(url_desc_map["conn"][0])
|
||||
if url.rfind("/") < len(url) - 1:
|
||||
url = url + "/"
|
||||
url = url + urllib.parse.unquote(url_desc_map["stream"][0])
|
||||
elif "stream" in url_desc_map and "conn" not in url_desc_map:
|
||||
url = urllib.parse.unquote(url_desc_map["stream"][0])
|
||||
|
||||
if "sig" in url_desc_map:
|
||||
url = url + "&sig=" + url_desc_map["sig"][0]
|
||||
elif "s" in url_desc_map:
|
||||
sig = url_desc_map["s"][0]
|
||||
flashvars = self.extractFlashVars(result, 1)
|
||||
js = flashvars["js"]
|
||||
url = url + "&sig=" + self.decrypt_signature(sig, js)
|
||||
|
||||
links[key] = url
|
||||
|
||||
return links
|
||||
|
||||
def decrypt_signature(self, s, js):
|
||||
return decryptor.decryptSignature(s, js)
|
||||
|
||||
|
||||
def extractVideoLinksFromYoutube(self, url, videoid, video):
|
||||
result = util.request(self.urls["video_stream"] % videoid)
|
||||
links = self.scrapeWebPageForVideoLinks(result, video, videoid)
|
||||
if len(links) == 0:
|
||||
util.error("Couldn't find video url- or stream-map.")
|
||||
return links
|
||||
# /*
|
||||
# * Copyright (C) 2011 Libor Zoubek
|
||||
# *
|
||||
# *
|
||||
# * This Program is free software; you can redistribute it and/or modify
|
||||
# * it under the terms of the GNU General Public License as published by
|
||||
# * the Free Software Foundation; either version 2, or (at your option)
|
||||
# * any later version.
|
||||
# *
|
||||
# * This Program is distributed in the hope that it will be useful,
|
||||
# * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# * GNU General Public License for more details.
|
||||
# *
|
||||
# * You should have received a copy of the GNU General Public License
|
||||
# * along with this program; see the file COPYING. If not, write to
|
||||
# * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
# * http://www.gnu.org/copyleft/gpl.html
|
||||
# *
|
||||
# */
|
||||
import re, util, urllib.request, urllib.parse, urllib.error
|
||||
__name__ = 'youtube'
|
||||
|
||||
|
||||
def supports(url):
|
||||
return not _regex(url) == None
|
||||
|
||||
def resolve(url):
|
||||
m = _regex(url)
|
||||
if not m == None:
|
||||
player = YoutubePlayer()
|
||||
video = {'title':'žádný název'}
|
||||
index = url.find('&') # strip out everytihing after &
|
||||
if index > 0:
|
||||
url = url[:index]
|
||||
links = player.extractVideoLinksFromYoutube(url, m.group('id'), video)
|
||||
resolved = []
|
||||
for q in links:
|
||||
if q in list(player.fmt_value.keys()):
|
||||
quality = player.fmt_value[q]
|
||||
item = {}
|
||||
item['name'] = __name__
|
||||
item['url'] = links[q]
|
||||
item['quality'] = quality
|
||||
item['surl'] = url
|
||||
item['subs'] = ''
|
||||
item['title'] = video['title']
|
||||
item['fmt'] = q
|
||||
resolved.append(item)
|
||||
return resolved
|
||||
|
||||
def _regex(url):
|
||||
return re.search('(www\.youtube\.com/(watch\?v=|v/|embed/)|youtu\.be/)(?P<id>.+?)(\?|$|&)', url, re.IGNORECASE | re.DOTALL)
|
||||
Reference in New Issue
Block a user